Compito

Definire una mod-fold in funzione della forma f (x) = x% a ₁  % a ₂  % ...% a _k , dove a _i sono numeri interi positivi e k ≥ 0 . (Qui % è l'operatore modulo associativo di sinistra.)

Dato un elenco di n numeri interi y ₀ ,…, y _{n − 1} , determinare se esiste una mod-fold f in modo che ogni y _i  = f (i) .

È possibile scegliere e correggere due uscite Y e N per la propria funzione / programma. Se esiste una tale f , devi sempre restituire / stampare esattamente Y ; in caso contrario, si deve sempre tornare / stampare esattamente N . (Questi potrebbero essere true/ false, o 1/ 0, o false/ true, ecc.) Menzionali nella tua risposta.

Vince l'invio più breve in byte.

Esempio

Definisci f (x) = x% 7% 3 . I suoi valori iniziano:

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

Quindi, dato 0 1 2 0 1 2 0 0 1 2come input per la nostra soluzione, stamperemmo Y , poiché questa f genera quella sequenza. Tuttavia, dato 0 1 0 1 2come input, stamperemmo N , poiché nessuna f genera quella sequenza.

Casi test

Le formule fornite quando l'output è Y sono solo per riferimento; non devi mai stamparli.

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 byte

}Qm%M+RdUQy_Sl

Ritorni True/False. Provalo online: Dimostrazione o Test Suite

Spiegazione:

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

q%M.e+k_tx0

Basato sull'idea di @ ferrsum . In realtà ho pensato di utilizzare gli indici zero per la generazione del sottoinsieme, ma non ho realizzato che tutti gli indici zero devono essere già la soluzione.

Python 3, 239 218 byte

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 funzione anonima che accetta input di un elenco ze restituisce Trueo Falseper Ye N.

Questo utilizza un metodo simile a 's @Jakube risposta , e anche se è essenzialmente una forza bruta, corre molto rapidamente.

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

Provalo su Ideone

Python 2, 69 byte

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)

Usi True/ False.

La risposta a ciò che caratterizza una serie mod-pieghevole risulta essere meno interessante di quanto sembri inizialmente. È una serie del modulo 0, 1, ..., M - 1, 0, 1, ... x ₁ , 0, 1, ..., x ₂ , ... tale che per tutti i, 0 <= x _i <M. Tale sequenza può essere prodotta dalla catena mod di tutti gli indici (basati su 0) degli zero nella matrice, escluso il primo.

Gelatina , 19 15 14 byte

LṗLUZ’1¦%/sLe@

Restituisce 1 per verità, 0 per falsa. Provalo online!

L'algoritmo è O (n ⁿ ) , dove n è la lunghezza dell'elenco, rendendolo troppo lento e dispendioso in termini di memoria per la maggior parte dei casi di test.

Una versione modificata, che sostituisce la seconda Lcon a 5, può essere utilizzata per verificare tutti i casi di test . Si noti che questa versione modificata non funzionerà per elenchi arbitrariamente lunghi.

Come funziona

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 byte

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

48 byte salvati passando alla scoperta di @ Feersum. Qualsiasi valore dato nnell'array è zero, nel qual caso la previsione successiva pè 1 oppure è uguale alla previsione successiva, nel qual caso pviene incrementata. Misuriamo anche la lunghezza ldella sequenza iniziale confrontandola pcon i, poiché ndeve essere sempre inferiore rispetto la sempre.

Python 2, 103 99 byte

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

Stampa 1 per verità e 0 per falsità. Provalo su Ideone .