Scrivi un programma per determinare se una sequenza periodica di numeri interi positivi ha la proprietà che, per ogni numero intero npresente nella sequenza, non ci sono mai più di naltri numeri interi tra due occorrenze consecutive di n.

Ad esempio, 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...ha questa proprietà: ogni coppia di occorrenze consecutive 2ha al massimo due numeri interi tra loro (come 2, 3, 5, 2e 2, 3, 6, 2; ogni coppia di occorrenze consecutive 3ha al massimo tre numeri interi tra loro; e la stessa per 5e 6.

Tuttavia, 2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ...non ha questa proprietà: due occorrenze consecutive di 4, cioè 4, 2, 3, 5, 2, 3, 4, hanno più di quattro numeri interi tra di loro.

Input : una rappresentazione ragionevole di una sequenza periodica di numeri interi positivi. Ad esempio, un elenco finito come {2, 3, 5, 2, 3, 6}può rappresentare la prima sequenza infinita 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...sopra. (In tal caso, il problema potrebbe essere affermato per elenchi finiti che vanno in giro invece che per infiniti elenchi periodici.)

Output : un valore di verità / falsità.

Esempi sinceri:

{1}
{8, 9}
{2, 3, 4}
{5, 5, 3, 3, 6}
{2, 3, 5, 2, 3, 6}
{6, 7, 3, 5, 3, 7}
{9, 4, 6, 7, 4, 5}
{1, 1, 1, 1, 1, 100, 1}
{1, 9, 1, 8, 1, 7, 1, 11}

Esempi di falsi:

{1, 2, 3}
{2, 3, 9, 5}
{3, 5, 4, 4, 6}
{2, 3, 5, 2, 3, 4}
{3, 5, 7, 5, 9, 3, 7}
{5, 6, 7, 8, 9, 10, 11}
{1, 9, 1, 8, 1, 6, 1, 11}

Questo è codegolf , quindi vince il codice più corto. Le risposte in tutte le lingue sono incoraggiate.

Haskell, 60 57 56 55 byte

f(a:b)=b==[]||length(fst$span(/=a)b)<=a&&f b
g x=f$x++x

Presuppone che l'elenco di input contenga almeno un elemento.

Esempio di utilizzo: g [1]-> True. Provalo online!

Lascia che asia il capo della lista e bla coda. Il risultato è Truese bè vuoto o il numero di elementi all'inizio del bquale non sono uguali a anon è maggiore di ae anche la chiamata ricorsiva di f bè True, altrimenti False. Inizia con due volte l'elenco di input.

Modifica: @Leo ha salvato 3 byte. Grazie!

Modifica 2: @Laikoni ha salvato 1 byte. Grazie!

Python , 57 56 byte

-1 byte grazie a Dennis (sostituire i+1:i+v+2con i:i-~vun ioffset 1 da enumerate)

lambda a:all(v in(a+a)[i:i-~v]for i,v in enumerate(a,1))

Provalo online!

Funzione senza nome prendendo una lista, ae testare la condizione che ogni valore, vappare inla fetta corrispondente alla sua destra in una concatenazione di acon se stesso, (a+a)[i:i-~v]dove l'indice a base 1 va a, iviene fornito da enumerate(a,1).

JavaScript (ES6), 67 65 55 54 51 49 byte

Salvato 3B grazie a @ETHproductions e 2B grazie a @Arnauld

a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

Spiegazione

Questo definisce una funzione che accetta un array acome input. Quindi, il .somemetodo scorre su quell'array, eseguendo un'altra funzione per ogni elemento.

Questa funzione interna accetta due argomenti be c, il valore corrente e il suo indice. La funzione trova l'indice del valore corrente, a partire dall'indice c + 1. Quindi controlla se questo indice è maggiore del valore corrente più l'indice corrente (la differenza tra due occorrenze dello stesso valore è maggiore di b). Nota che questo restituisce l'esatto contrario di ciò che vogliamo.

Se uno di questi valori di ritorno è true, anche la .somefunzione ritorna true. Se nessuno dei controlli ritorna true, la .somefunzione ritorna false. Ancora una volta l'opposto del valore che vogliamo restituire, quindi questo risultato viene negato e quindi restituito.

Provalo

Prova tutti i casi di test qui:

let f=
a=>!a.some((b,c)=>a.concat(a).indexOf(b,++c)>b+c)

let truthy = [[1], [8, 9], [2, 3, 4], [5, 5, 3, 3, 6], [2, 3, 5, 2, 3, 6], [6, 7, 3, 5, 3, 7], [9, 4, 6, 7, 4, 5], [1, 1, 1, 1, 1, 100, 1], [1, 9, 1, 8, 1, 7, 1, 11]];
let falsy  = [[1, 2, 3], [2, 3, 9, 5], [3, 5, 4, 4, 6], [2, 3, 5, 2, 3, 4], [3, 5, 7, 5, 9, 3, 7], [5, 6, 7, 8, 9, 10, 11], [1, 9, 1, 8, 1, 6, 1, 11]];

console.log("Truthy test cases:");
for (let test of truthy) {
    console.log(`${test}: ${f(test)}`);
}

console.log("Falsy test cases:");
for (let test of falsy) {
    console.log(`${test}: ${f(test)}`);
}

Gelatina , 11 byte

ṣZL
;çЀ<‘P

Provalo online!

Come funziona

;çЀ<‘P  Main link. Argument: A (array)

;        Concatenate A with itself.
 çD€     For each n in A, call the helper with left arg. A + A and right arg. n.
     ‘   Increment all integers in A.
    <    Perform element-wise comparison of the results to both sides.
      P  Take the product of the resulting Booleans.


ṣZL      Helper link. Left argument: A. Right argument: n

ṣ        Split A at all occurrences of n.
 Z       Zip to transpose rows and columns.
  L      Length; yield the number of rows, which is equal to the number of columns
         of the input to Z.

Gelatina , 8 byte

ṙJḣ"‘Œpċ

Insipred dalla risposta Python di @ JonathanAllan .

Provalo online!

Come funziona

ṙJḣ"‘Œpċ  Main link. Argument: A (array)

 J        Yield the indicies of A, i.e., [1, ..., len(A)].
ṙ         Rotate; yield A, rotated 1, ..., and len(A) units rotated to the left.
    ‘     Increment; add 1 to all elements of A.
  ḣ"      Head zipwith; truncate the n-th rotation to length A[n]+1.
     Œp   Take the Cartesian product of all resulting truncated rotations.
       ċ  Count the number of times A appears in the result.

SWI-Prolog, 83 byte

a(L,[H|R]):-nth0(X,R,H),H>=X,a(L,R);length(R,N),nth0(X,L,H),H>=N+X,a(L,R).
a(_,[]).

L'elenco deve essere inserito due volte:

a([1,2,3],[1,2,3]).

Se questo non è considerato accettabile, è possibile aggiungere il predicato

a(L):-a(L,L).

che aggiunge altri 14 byte.

Provalo online

nb: è possibile verificare contemporaneamente diversi casi falsi separando le query con ';' (o) e verifica i diversi casi reali separando con ',' (e)

cioè, usando gli esempi OP:

a([1],[1]),
a([8, 9],[8, 9]),
a([2, 3, 4],[2, 3, 4]),
a([5, 5, 3, 3, 6],[5, 5, 3, 3, 6]),
a([2, 3, 5, 2, 3, 6],[2, 3, 5, 2, 3, 6]),
a([6, 7, 3, 5, 3, 7],[6, 7, 3, 5, 3, 7]),
a([9, 4, 6, 7, 4, 5],[9, 4, 6, 7, 4, 5]),
a([1, 1, 1, 1, 1, 100, 1],[1, 1, 1, 1, 1, 100, 1]),
a([1, 9, 1, 8, 1, 7, 1, 11],[1, 9, 1, 8, 1, 7, 1, 11]).

e

a([1, 2, 3],[1, 2, 3]);
a([2, 3, 9, 5],[2, 3, 9, 5]);
a([3, 5, 4, 4, 6],[3, 5, 4, 4, 6]);
a([2, 3, 5, 2, 3, 4],[2, 3, 5, 2, 3, 4]);
a([3, 5, 7, 5, 9, 3, 7],[3, 5, 7, 5, 9, 3, 7]);
a([5, 6, 7, 8, 9, 10, 11],[5, 6, 7, 8, 9, 10, 11]);
a([1, 9, 1, 8, 1, 6, 1, 11],[1, 9, 1, 8, 1, 6, 1, 11]).

PHP, 52 byte

for(;$n=$argv[++$i];$$n=$i)!$$n|$i-$$n<$n+2?:die(1);

prende la sequenza dagli argomenti della riga di comando; esce con il codice 1per falsy, 0per verità.
Corri con -nr.

• $nargomenti loop :
  • se non si verificava un evento precedente o era abbastanza recente
    , non fare nulla, altrimenti uscire con il codice1
  • ricordare la ricorrenza precedente in $$n( variabili variabili )
• esci con codice 0(implicito)

Retina , 50 byte

$
,$`
M!&`\b(1+),.*?\b\1\b
+%`(^1*)1,1+
$1
M`1,
^0

Immettere come elenco di numeri unari separati da virgola.

Provalo online!

Spiegazione

$
,$`

Duplica l'input in modo da poter controllare i passaggi che avvolgono la fine.

M!&`\b(1+),.*?\b\1\b

Abbina e restituisci ciascuna sezione (più breve) tra due valori identici, ad es 11,111,1,11.

+%`(^1*)1,1+
$1

Rimuovere ripetutamente una cifra dal primo numero, insieme a un numero intero dopo di esso. Se lo spazio è abbastanza piccolo, questo rimuoverà completamente il primo numero. Altrimenti, rimarrà almeno una cifra.

M`1,

Conta la frequenza con cui 1,appare in tutte le righe. Se appare ovunque, uno dei passaggi era troppo largo.

^0

Prova ad abbinare un numero che inizia con 0(cioè solo 0se stesso). Questa è effettivamente una negazione logica dell'output.

JavaScript (ES6), 47 byte

a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

Come funziona

Riutilizziamo l'array di input aper memorizzare la posizione dell'ultima occorrenza rilevata di ciascun numero intero in a. Usiamo la chiave -nper memorizzare questa posizione in modo che non interferisca con gli indici originali di a.

Quando a[-n]esiste, si verifica il test effettivo. Quando a[-n]non esiste, l'espressione è a[-n] - (a[-n] = i)uguale undefined - i == NaNe il confronto con ~nè sempre falso, che è il risultato atteso.

Casi test

f=
a=>![...a,...a].some((n,i)=>a[-n]-(a[-n]=i)<~n)

console.log('Truthy cases:');
console.log(f([1]));
console.log(f([8, 9]));
console.log(f([2, 3, 4]));
console.log(f([5, 5, 3, 3, 6]));
console.log(f([2, 3, 5, 2, 3, 6]));
console.log(f([6, 7, 3, 5, 3, 7]));
console.log(f([9, 4, 6, 7, 4, 5]));
console.log(f([1, 1, 1, 1, 1, 100, 1]));
console.log(f([1, 9, 1, 8, 1, 7, 1, 11]));

console.log('Falsy cases:');
console.log(f([1, 2, 3]));
console.log(f([2, 3, 9, 5]));
console.log(f([3, 5, 4, 4, 6]));
console.log(f([2, 3, 5, 2, 3, 4]));
console.log(f([3, 5, 7, 5, 9, 3, 7]));
console.log(f([5, 6, 7, 8, 9, 10, 11]));
console.log(f([1, 9, 1, 8, 1, 6, 1, 11]));

Retina ,  41 39 byte

2 byte giocati a golf grazie a Martin Ender, che tra l'altro mi ha fatto conoscere i gruppi di bilanciamento con la sua fantastica guida su SO

$
,$`,
((1)+,)(?=(?<-2>1+,)*(\1|$))

^$

L'input è un elenco separato da virgole di numeri unari. L'output è 0per falso e 1per vero.

Provalo online! (Suite di test che converte automaticamente da decimale)

Di recente ho imparato a conoscere i gruppi di bilanciamento, quindi volevo provarli. Non sono tra gli strumenti più facili da usare, ma sicuramente sono potenti.

Spiegazione

$
,$`,

Come molti altri invii, dupliciamo l'elenco per gestire il wrapping. Aggiungiamo anche una virgola alla fine, quindi ogni numero è seguito da una virgola (questo rende le cose un po 'più facili in seguito)

((1)+,)(?=(?<-2>1+,)*(\1|$))

Ecco dove le cose si fanno interessanti. Questa è una fase di sostituzione, sostituiamo tutto ciò che corrisponde alla prima riga con la seconda riga, in questo caso stiamo cercando di rimuovere tutti i numeri nnon seguiti da n+1altri numeri diversi.

Per fare ciò, per prima cosa abbiniamo il numero, catturandoli ciascuno 1in un gruppo (catturando il gruppo numero 2 in questo caso). Quindi, con uno sguardo positivo, al fine di avere un'asserzione di larghezza zero, proviamo ripetutamente ad abbinare in un gruppo di bilanciamento -2, che non riuscirà più del numero di acquisizioni effettuate dal gruppo 2, un numero seguito da una virgola. Dopo questa sequenza di numeri, siamo soddisfatti se raggiungiamo nuovamente il primo numero o la fine della riga.

Nota: questa espressione potrebbe corrispondere solo alla parte finale di un numero, se non riesce a trovare una corrispondenza con il numero completo. Questo non è un problema, perché la prima parte del numero rimarrà nella stringa e sapremo che la sostituzione non è riuscita completamente.

^$

Infine, il risultato dovrebbe essere veritiero se abbiamo rimosso completamente tutti i numeri dall'elenco. Cerchiamo di abbinare la stringa vuota e restituire il numero di corrispondenze trovate.

Gelatina , 11 byte

ẋ2ĠṢI_2<"QȦ

Provalo online!

ẋ2ĠṢI_2<"QȦ  Main link. Argument: A (array)

ẋ2           Repeat A twice to account for wrap-around.
  Ġ          Group all indices of A + A by their respective values, sorting the
             index groups by the associated values.
   Ṣ         Sort the groups lexicographically, i.e., by first appearance in A.
    I        Increments; compute the forward differences of adjacent indices in
             each of the groups.
     _2      Subtract 2 from the differences.
         Q   Unique; yield A, deduplicated.
       <"    Compare all differences in the index group corresponding to the n-th
             unique value in A with the n-th unqiue value in A.
          Ȧ  All; yield 1 if and only if none of the comparisons returned 0.

Python 3 , 101 byte

lambda l:all(v>=(l[i+1:].index(v)if v in l[i+1:]else len(l[i+1:])+l.index(v))for i,v in enumerate(l))

Provalo online!

Röda , 50 byte

f a{seq 0,#a-1|[indexOf(a[_],a[_1+1:]..a)<=a[_1]]}

Provalo online!

Finalmente! Ho aspettato per questa sfida ...

È una funzione che restituisce un valore di verità o di falsità. Ci vuole un argomento, l'array.

Esegue un'iterazione su un flusso di indici e verifica per ciascun indice _1che la distanza tra l'indice corrente e l'indice successivo a[_1]non sia maggiore di a[_1].

05AB1E , 13 byte

Dì©v®¦©yky›_P

Provalo online! o come una suite di test

Spiegazione

Dì             # duplicate input and prepend the copy to the original
  ©            # store a copy in the register
   v           # for each element in the list
    ®          # push the list from register
     ¦©        # remove the first element and store a copy in the register
       yk      # get the index of the current element in the list
         y›_   # check if it's less than or equal to the current element
            P  # product of stack