Python 分解函数

我一直在思考如何让某个函数在Python中工作。函数本身是这样的：

(Phi_m)x((n2)) = (Phi_m)(x(m*n + r)) = m*x[n1] + r*(x([n1] + 1) - x[n1])

注意：这里的n只是指定一些倍数。它不是列表元素，但当应用x时，它将成为列表元素。例如，在下面的示例中，我们可能会发现n大于列表中的任何元素。例如，一个列表有9个元素，最大的是3个，m=1-这里n=9=/=列表的元素

其中n2和n1是输入字符串的两个不同值，其中n1通过“分解”n2导出。我们认为<代码> x〔0〕＝0＜/CODE＞<代码> r总是为零或正而小于<代码> M< /代码>，并且<代码> N< /代码>（它们中的任何一个）都是正整数。通常，函数接受一个数字字符串并输出另一个字符串。通常情况下，我们修复一个

m

，比如

m=2

。现在我们分解

n2

。说

n2=5

。然后

F（x（5））=F（x（2*2+1））2x[2]+1（x[3]-x[2]）

。因此，如果我们的完整输入序列是

0,1,1,2,3,3

，我们将得到

2*1+0=2

。所以我们的第五个输出项是

2

我最初想做一些事情，比如：

x = [0,1,1,2,3,3,3,3]

def F(n,j,r,x):
return j * x[n] + r(x[n + 1] - x[n])
for n in range(len(x) - 1):
    print n

但这显然不符合我的目的

---

问题是，Python要做到这一点，必须知道如何分解每个数字。所以它知道

2

是固定的，知道

2*3

太多，所以选择

2*2

。然后它必须知道这太少，并添加余数

1

。只有这样，它才能真正抓取

n=5

。也就是说，它可以运行函数。很明显，一旦它知道如何做，它就可以运行我们范围内的每个

n

，但我真的不知道如何编程这个函数的具体内容。

下面是我如何将一个数字分解为

n2=m*n1+r

：

>>> def decompose(number):
...     # returns a generator of tuples (m, n1, r)
...     for m in range(1, number+1):
...         yield m, number // m, number % m
... 
>>> for m, n1, r in decompose(5):
...     print "5 = %s * %s + %s" % (m, n1, r)
... 
5 = 1 * 5 + 0
5 = 2 * 2 + 1
5 = 3 * 1 + 2
5 = 4 * 1 + 1
5 = 5 * 1 + 0

或者使用固定的

m

，这与常规的

divmod

相同：

>>> def decompose(number):
...     return number // m, number % m
... 
>>> m = 2
>>> n1, r = decompose(5)
>>> print "5 = %s * %s + %s" % (m, n1, r)
5 = 2 * 2 + 1
>>> m = 4
>>> n1, r = decompose(5)
>>> print "5 = %s * %s + %s" % (m, n1, r)
5 = 4 * 1 + 1

或者更简单地使用

lambda

：

>>> decompose = lambda number: divmod(number, m)
>>> 
>>> m = 2
>>> decompose(5)
(2, 1)
>>> m = 4
>>> decompose(5)
(1, 1)

现在，作为一个完整的例子：

>>> decompose = lambda number: divmod(number, m)
>>> 
>>> class Phi_m(list):
...     def __init__(self, items):
...         list.__init__(self)
...         # you need to know at least m numbers.
...         assert len(items) >= m, 'Not enough data'
...         list.extend(self, items)
...     # this is a sparse list
...     # http://stackoverflow.com/questions/1857780/sparse-assignment-list-in-python
...     def __setitem__(self, index, value):
...         missing = index - len(self) + 1
...         if missing > 0:
...             self.extend([None] * missing)
...             list.__setitem__(self, index, value)
...     def __getitem__(self, index):
...         try:
...             value = list.__getitem__(self, index)
...             if value is not None:
...                 # the item is in the list, yeah!
...                 return value
...             # the item is in the list because it was resized
...             # but it is None, so go on and calculate it. 
...         except IndexError:
...             # the item is not in the list, calculate it.
...             pass
...         print 'calculating Fm[%s]' % index
...         A, B = decompose(index)
...         value1 = self.__getitem__(A)
...         value2 = self.__getitem__(A + 1)
...         print 'Fm[A=%s] = %s, Fm[A+1=%s] = %s' % (A, value1, A+1, value2)
...         print 'back to calculating Fm[%s]' % index
...         # m * x[n1] + r * (x[n1 + 1] - x[n1]) = (m - r) * x[n1] + r * x[n1 + 1]
...         # A = n1 ; B = r ; value1 = x[n1] ; value2 = x[n+1]
...         value = (m - B) * value1 + B * value2
...         self.__setitem__(index, value)
...         return value
... 
>>> x = Phi_m([0, 1, 1])
>>> 
>>> x[5]
calculating Fm[5]
calculating Fm[3]
Fm[A=1] = 1, Fm[A+1=2] = 1
back to calculating Fm[3]
Fm[A=2] = 1, Fm[A+1=3] = 2
back to calculating Fm[5]
3
>>> 
>>> 

---

下面是我如何将一个数字分解为

n2=m*n1+r

：

>>> def decompose(number):
...     # returns a generator of tuples (m, n1, r)
...     for m in range(1, number+1):
...         yield m, number // m, number % m
... 
>>> for m, n1, r in decompose(5):
...     print "5 = %s * %s + %s" % (m, n1, r)
... 
5 = 1 * 5 + 0
5 = 2 * 2 + 1
5 = 3 * 1 + 2
5 = 4 * 1 + 1
5 = 5 * 1 + 0

或者使用固定的

m

，这与常规的

divmod

相同：

>>> def decompose(number):
...     return number // m, number % m
... 
>>> m = 2
>>> n1, r = decompose(5)
>>> print "5 = %s * %s + %s" % (m, n1, r)
5 = 2 * 2 + 1
>>> m = 4
>>> n1, r = decompose(5)
>>> print "5 = %s * %s + %s" % (m, n1, r)
5 = 4 * 1 + 1

或者更简单地使用

lambda

：

>>> decompose = lambda number: divmod(number, m)
>>> 
>>> m = 2
>>> decompose(5)
(2, 1)
>>> m = 4
>>> decompose(5)
(1, 1)

现在，作为一个完整的例子：

>>> decompose = lambda number: divmod(number, m)
>>> 
>>> class Phi_m(list):
...     def __init__(self, items):
...         list.__init__(self)
...         # you need to know at least m numbers.
...         assert len(items) >= m, 'Not enough data'
...         list.extend(self, items)
...     # this is a sparse list
...     # http://stackoverflow.com/questions/1857780/sparse-assignment-list-in-python
...     def __setitem__(self, index, value):
...         missing = index - len(self) + 1
...         if missing > 0:
...             self.extend([None] * missing)
...             list.__setitem__(self, index, value)
...     def __getitem__(self, index):
...         try:
...             value = list.__getitem__(self, index)
...             if value is not None:
...                 # the item is in the list, yeah!
...                 return value
...             # the item is in the list because it was resized
...             # but it is None, so go on and calculate it. 
...         except IndexError:
...             # the item is not in the list, calculate it.
...             pass
...         print 'calculating Fm[%s]' % index
...         A, B = decompose(index)
...         value1 = self.__getitem__(A)
...         value2 = self.__getitem__(A + 1)
...         print 'Fm[A=%s] = %s, Fm[A+1=%s] = %s' % (A, value1, A+1, value2)
...         print 'back to calculating Fm[%s]' % index
...         # m * x[n1] + r * (x[n1 + 1] - x[n1]) = (m - r) * x[n1] + r * x[n1 + 1]
...         # A = n1 ; B = r ; value1 = x[n1] ; value2 = x[n+1]
...         value = (m - B) * value1 + B * value2
...         self.__setitem__(index, value)
...         return value
... 
>>> x = Phi_m([0, 1, 1])
>>> 
>>> x[5]
calculating Fm[5]
calculating Fm[3]
Fm[A=1] = 1, Fm[A+1=2] = 1
back to calculating Fm[3]
Fm[A=2] = 1, Fm[A+1=3] = 2
back to calculating Fm[5]
3
>>> 
>>> 

---

---

函数不应该是从向量空间到标量场的映射吗？我不知道您为什么希望它输出一个数字列表。您确定

python

是正确的标记吗？你是说你知道如何编写代码，但你不知道如何用Python编写代码？或者你是说你不知道用什么算法来编写任何语言的代码？@user2357112你是对的，我应该把它称为函数。@kojiro我不是，但我希望用Python编写它（这似乎最简单）。事实上，我不知道如何用任何语言编写它。分解是如何工作的？它只是吗？难道函数不应该是从向量空间到标量场的映射吗？我不知道您为什么希望它输出一个数字列表。您确定

python

是正确的标记吗？你是说你知道如何编写代码，但你不知道如何用Python编写代码？或者你是说你不知道用什么算法来编写任何语言的代码？@user2357112你是对的，我应该把它称为函数。@kojiro我不是，但我希望用Python编写它（这似乎最简单）。事实上，我不知道如何用任何语言编写它。分解是如何工作的？只是吗？谢谢！这是一个好主意，唯一的问题是它为各种m值提供了分解，这虽然有用，但与我希望它能够做到的略有不同。理想情况下，m从一开始就是固定的，然后输入字符串的所有未来计算都将基于这样的假设，即我们生活在一个只有m值的世界中。再次感谢dnozay。我只是在犹豫是否能给你一个被接受的答案，因为@user2357112似乎是他计划回答的，我应该等到我确定能接受为止。也就是说，一旦我有了这样做的名声，我肯定会把你的答案标记为有用！去接受吧。我以为你想要的不止这些；如果唯一让您困惑的部分是分解，那么这是一个很好的答案。@user2357112事实上，理想情况下，我想要的不仅仅是分解。您是否有全面实施该功能的想法？我永远也不知道我还能得到多少其他答案，如果不相信那些为自己的回答付出了努力的人，我会感到有点难过。@dnozay谢谢！我应该提到的一个可能的问题是，您不需要知道m个数字。例如，如果m=8，并且您的数字字符串是011（长度3），您仍然可以计算：012，因为您将有1=8*0+1，2=8*0+2。另一个原因是，我在复制您的>>>x=Phi_m（[0，1，1]）示例时遇到语法错误。谢谢！这是一个好主意，唯一的问题是它为各种m值提供了分解，这虽然有用，但与我希望它能够做到的略有不同。理想情况下，m从一开始就是固定的，然后输入字符串的所有未来计算都将基于这样的假设，即我们生活在一个只有m值的世界中。再次感谢dnozay。我只是在犹豫是否能给你一个被接受的答案，因为@user2357112似乎是他计划回答的，我应该等到我确定能接受为止。也就是说，一旦我有了这样做的名声，我肯定会把你的答案标记为有用！去接受吧。我以为你想要的不止这些；如果唯一让您困惑的部分是分解，那么这是一个很好的答案。@user2357112事实上，理想情况下，我想要的不仅仅是分解。您是否有全面实施该功能的想法？我永远也不知道我还能得到多少其他的答案，如果不相信那些为自己的事业付出了努力的人，我会感到有点难过