任务

根据形式f（x）= x％a ₁  ％a ₂  ％…％a _k定义mod折叠，其中a _i是正整数，且k≥0。（此处，％是左联想模运算符。）

给定n个整数y ₀，…，y _n-1的列表，确定是否存在模倍f，以便每个y _i  = f（i）。

您可以为功能/程序选择并固定任意两个输出 Y和N。如果存在这样的f，则必须始终完全返回/打印Y；如果没有，你必须总是返回/打印准确ñ。（这些可能是true/ false，或1/ 0或false/ true等）。在您的答案中提及这些。

以字节为单位的最短提交获胜。

例

定义f（x）= x％7％3。其值开始：

|   x  | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ...
| f(x) | 0 | 1 | 2 | 0 | 1 | 2 | 0 | 0 | 1 | 2 | ...

因此，0 1 2 0 1 2 0 0 1 2作为解决方案的输入，我们将打印Y，因为此f生成该序列。但是，0 1 0 1 2作为输入，我们将打印N，因为没有f生成该序列。

测试用例

当输出为Y时给出的公式仅供参考；您绝对不能打印它们。

0 1 2 3 4 5              Y    (x)
1                        N
0 0 0                    Y    (x%1)
0 1 2 0 1 2 0 0 1 2      Y    (x%7%3)
0 0 1                    N
0 1 2 3 4 5 6 0 0 1 2    Y    (x%8%7)
0 1 2 0 1 2 0 1 2 3      N
0 2 1 0 2 1 0 2 1        N
0 1 0 0 0 1 0 0 0 0 1    Y    (x%9%4%3%2)

Pyth，14个字节

}Qm%M+RdUQy_Sl

返回True/False。在线尝试：演示或测试套件

说明：

}Qm%M+RdUQy_SlQ   implicit Q (=input) at the end
             lQ   length of input list
            S     create the list [1, 2, ..., len]
           _      reverse => [len, ..., 2, 1]
          y       generate all subsets (these are all possible mod-folds)
  m               map each subset d to:
        UQ           take the range [0, 1, ..., len-1]
     +Rd             transform each number into a list by prepending it to d
                     e.g. if mod-fold = [7,3], than it creates:
                        [[0,7,3], [1,7,3], [2,7,3], [3,7,3], ...]
   %M                fold each list by the modulo operator
                  this gives all possible truthy sequences of length len
}Q                so checking if Q appears in the list returns True or False

Pyth，11个字节

q%M.e+k_tx0

基于@ferrsum的想法。我实际上考虑过将零索引用于子集生成，但是没有意识到，所有零索引都已经是解决方案。

Python 3中，239个 218字节

from itertools import*
lambda z:z in[[eval(''.join([str(l)]+['%'+str(i[::-1][k])for k in range(len(i))]))for l in range(len(z))]for i in(i for j in(combinations(range(1,len(z)+1),i+1)for i in range(len(z)))for i in j)]

匿名函数，接受列表的输入z并返回True或Falsefor Y和N。

它使用类似于@Jakube的answer的方法，尽管它本质上是一种蛮力，但运行速度非常快。

from itertools import*               Import everything from the Python module for
                                     iterable generation
lambda z                             Anonymous function with input list z
combinations(range(1,len(z)+1),i+1)  Yield all sorted i+1 length subsets of the range
                                     [1,len(z)]...
...for i in range(len(z))            ...for all possible subset lengths
(i for j in(...)for i in j)          Flatten, yielding an iterator containing all possible
                                     mod-fold values as separate lists
...for i in...                       For all possible mod-fold values...
...for k in range(len(i))            ...for all mod-fold values indices k...
...for l in range(len(z))            ...for all function domain values in [0,len(z)-1]...
[str(l)]+['%'+str(i[::-1][k])...]    ...create a list containing each character of the
                                     expression representing the function defined by the
                                     mod-fold values (reversed such that the divisors
                                     decrease in magnitude) applied to the domain value...
 eval(''.join(...))                  ...concatenate to string and evaluate...
 [...]                               ...and pack all the values for that particular
                                     function as a list
 [...]                               Pack all lists representing all functions into a list
 ...:z in...                         If z is in this list, it must be a valid mod-fold, so
                                     return True. Else, return False

在Ideone上尝试

Python 2，69个字节

f=lambda a,i=0:i/len(a)or a[i]in[a[i-1]+1,i,0][i<=max(a)::2]*f(a,i+1)

使用True/ False。

事实证明，可折叠折叠系列的特征答案并不像最初看起来那么有趣。它是一系列的形式0,1，...，M - 1，0，1，......，X ₁，0，1，...，X ₂，...，使得对于所有的i，0 <= x _i <M。这样的序列可以由数组中所有零（从0开始）的索引（不包括第一个）的mod链生成。

果冻，19 15 14 字节

LṗLUZ’1¦%/sLe@

返回1表示真实，0表示虚假。在线尝试！

该算法为O（n ⁿ），其中n是列表的长度，对于大多数测试用例而言，它太慢且占用大量内存。

修改后的版本-它取代了第二L带5-可被用于验证所有测试用例。请注意，此修改版本不适用于任意较长的列表。

怎么运行的

LṗLUZ’1¦%/sLe@  Main link. Argument: A (array of integers)

L L             Yield the length l of A.
 ṗ              Take the l-th Cartesian power of [1, ..., l], i.e., construct
                all arrays of length l that consist of elements of [1, ..., l].
   U            Upend/reverse each array. This way, the first l arrays start
                with [1, ..., l], as do the next l arrays, etc.
    Z           Zip/transpose the array of arrays.
     ’1¦        Decrement the first array to map [1, ..., l] to [0, ..., l - 1].
        %/      Reduce the array's columns by modulus/residue.
          sL    Split the result into chunks of length l.
            e@  Verify if A belongs to the resulting array.

JavaScript（ES6），98个字节

a=>a.every((n,i)=>n?n<(l+=p==i)&&n==p++:p=1,l=p=1)

切换到@Feersum的发现，节省了48个字节。n数组中的任何给定值要么为零（在这种情况下，下一个预测p为1），要么等于下一个预测，在这种情况下p为增量。我们还测量长度l通过比较初始序列p来i，因为n必须始终小于l在任何时候。

Python 2，103 99字节

f=lambda l,r:r==x or l and f(l-1,[t%l for t in r])|f(l-1,r)
x=input();l=len(x);print+f(l,range(l))

打印1表示真实，打印0表示虚假。在Ideone上进行测试。