Tarea

Defina un pliegue mod en función de la forma f (x) = x% a ₁  % a ₂  %…% a _k , donde a _i son enteros positivos yk ≥ 0 . (Aquí, % es el operador de módulo asociativo a la izquierda).

Dada una lista de n enteros y ₀ , ..., y _{n − 1} , determine si existe un pliegue mod f para que cada y _i  = f (i) .

Puede elegir y corregir dos salidas Y y N para su función / programa. Si existe tal f , siempre debe devolver / imprimir exactamente Y ; si no, siempre hay que volver / imprimir exactamente N . (Estos podrían ser true/ false, o 1/ 0, o false/ true, etc.) Mencione estos en su respuesta.

La presentación más corta en bytes gana.

Ejemplo

Definir f (x) = x% 7% 3 . Sus valores comienzan:

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

Por lo tanto, dado 0 1 2 0 1 2 0 0 1 2como entrada a nuestra solución, imprimiríamos Y , ya que esta f genera esa secuencia. Sin embargo, dado 0 1 0 1 2como entrada, imprimiríamos N , ya que no f genera esa secuencia.

Casos de prueba

Las fórmulas dadas cuando la salida es Y son solo para referencia; en ningún momento debe imprimirlos.

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 bytes

}Qm%M+RdUQy_Sl

Las devoluciones True/False. Pruébelo en línea: Demostración o conjunto de pruebas

Explicación:

}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 bytes

q%M.e+k_tx0

Basado en la idea de @ ferrsum . De hecho, pensé en usar los índices cero para la generación de subconjuntos, pero no me di cuenta de que todos los índices cero ya deben ser la solución.

Python 3, 239 218 bytes

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)]

Una función anónima que toma la entrada de una lista zy devuelve Trueo Falsepara Yy N.

Esto utiliza un método similar a la respuesta de @Jakube y, aunque es esencialmente una fuerza bruta, se ejecuta muy rápidamente.

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

Pruébalo en Ideone

Python 2, 69 bytes

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)

Usos True/ False.

La respuesta a lo que caracteriza a una serie plegable mod resulta ser menos interesante de lo que parece al principio. Es una serie de la forma 0, 1, ..., M - 1, 0, 1, ... x ₁ , 0, 1, ..., x ₂ , ... de modo que para todo i, 0 <= x _i <M. Dicha secuencia puede ser producida por la cadena de modulación de todos los índices (basados ​​en 0) de los ceros en la matriz, excluyendo el primero.

Jalea , 19 15 14 bytes

LṗLUZ’1¦%/sLe@

Devuelve 1 para la verdad, 0 para la falsedad. Pruébalo en línea!

El algoritmo es O (n ⁿ ) , donde n es la longitud de la lista, por lo que es demasiado lenta y requiere mucha memoria para la mayoría de los casos de prueba.

Se puede usar una versión modificada, que reemplaza la segunda Lcon a 5, para verificar todos los casos de prueba . Tenga en cuenta que esta versión modificada no funcionará para listas arbitrariamente largas.

Cómo funciona

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 bytes

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

Ahorró 48 bytes al cambiar al descubrimiento de @ Feersum. Cualquier valor dado nen la matriz es cero, en cuyo caso la próxima predicción pes 1, o es igual a la siguiente predicción, en cuyo caso pse incrementa. También medimos la longitud lde la secuencia inicial mediante la comparación pde i, como ndebe ser siempre menor que len todo momento.

Python 2, 103 99 bytes

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))

Imprime 1 para la verdad y 0 para la falsedad. Pruébalo en Ideone .