Escriba un programa para determinar si una secuencia periódica de enteros positivos tiene la propiedad de que, por cada entero que nocurre en la secuencia, nunca hay más que notros enteros entre dos ocurrencias consecutivas n.

Por ejemplo, 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...tiene esta propiedad: cada par de ocurrencias consecutivas de 2tener como máximo dos enteros entre ellas (como 2, 3, 5, 2y 2, 3, 6, 2; cada par de ocurrencias consecutivas de 3tener como máximo tres enteros entre ellas; y lo mismo para 5y 6.

Sin embargo, 2, 3, 5, 2, 3, 4, 2, 3, 5, 2, 3, 4, ...no tiene esta propiedad: dos ocurrencias consecutivas de 4, a saber 4, 2, 3, 5, 2, 3, 4, tienen más de cuatro enteros entre ellas.

Entrada : una representación razonable de una secuencia periódica de enteros positivos. Por ejemplo, una lista finita como {2, 3, 5, 2, 3, 6}puede representar la primera secuencia infinita 2, 3, 5, 2, 3, 6, 2, 3, 5, 2, 3, 6, ...anterior. (Para el caso, el problema podría plantearse para listas finitas que se envuelven en lugar de para listas periódicas infinitas).

Salida : un valor verdadero / falso.

Ejemplos verdaderos:

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

Falsy ejemplos:

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

Este es codegolf , por lo que gana el código más corto. Se alientan las respuestas en todos los idiomas.

Haskell 60 60 57 56 55 bytes

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

Asume que la lista de entrada contiene al menos un elemento.

Ejemplo de uso: g [1]-> True. Pruébalo en línea!

Deje aser el jefe de la lista y bla cola. El resultado es Truesi bestá vacío o el número de elementos al principio de bque no son iguales a ano es mayor que ay la llamada recursiva de f bes también True, de lo contrario False. Comience con el doble de la lista de entrada.

Editar: @Leo guardó 3 bytes. ¡Gracias!

Edición 2: @Laikoni guardó 1 byte. ¡Gracias!

Python , 57 56 bytes

-1 bytes gracias a Dennis (reemplace i+1:i+v+2con i:i-~vcon un idesplazamiento de 1 a enumerate)

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

Pruébalo en línea!

Función sin nombre que toma una lista, ay probar la condición de que cada valor, vaparece inla rebanada pertinente a su derecha en una concatenación de aconsigo mismo, (a+a)[i:i-~v], donde el índice basado en 1 de ven a, i, es proporcionado por enumerate(a,1).

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

Ahorro 3B gracias a @ETHproductions y 2B gracias a @Arnauld

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

Explicación

Esto define una función que toma una matriz acomo entrada. Luego, el .somemétodo itera sobre esa matriz, ejecutando otra función para cada elemento.

Esta función interna toma dos argumentos, by c, el valor actual y su índice. La función encuentra el índice del valor actual, comenzando por el índice c + 1. Luego verifica si este índice es mayor que el valor actual más el índice actual (la diferencia entre dos ocurrencias del mismo valor es mayor que b). Tenga en cuenta que esto devuelve exactamente lo contrario de lo que queremos.

Si uno de estos valores de retorno es true, la .somefunción también regresa true. Si ninguno de los cheques regresa true, la .somefunción regresa false. Una vez más, lo contrario del valor que queremos devolver, por lo que este resultado se niega y luego se devuelve.

Pruébalo

Pruebe todos los casos de prueba aquí:

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)}`);
}

Jalea , 11 bytes

ṣZL
;çЀ<‘P

Pruébalo en línea!

Cómo funciona

;çЀ<‘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.

Jalea , 8 bytes

ṙJḣ"‘Œpċ

Insipred by @ JonathanAllan's Python answer .

Pruébalo en línea!

Cómo funciona

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

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(_,[]).

La lista debe ingresarse dos veces:

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

Si esto no se considera aceptable, puede agregar el predicado

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

que agrega 14 bytes adicionales.

Pruébalo en línea

nb: puede probar diferentes casos falsos a la vez separando sus consultas con ';' (o) y pruebe diferentes casos verdaderos separándolos con ',' (y)

es decir, usando los ejemplos de 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]).

y

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 bytes

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

toma secuencia de argumentos de línea de comando; sale con código 1de falsedad, 0de verdad.
Corre con -nr.

• bucle $na través de argumentos:
  • si no hubo una ocurrencia previa o si fue lo suficientemente reciente
    , no haga nada, de lo contrario salga con el código1
  • recordar ocurrencia previa en $$n( variables variables )
• salir con código 0(implícito)

Retina , 50 bytes

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

Ingrese como una lista de números unarios separados por comas.

Pruébalo en línea!

Explicación

$
,$`

Duplique la entrada para que podamos verificar los pasos que se ajustan al final.

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

Empareje y devuelva cada sección (la más corta) entre dos valores idénticos, por ejemplo 11,111,1,11.

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

Repetidamente elimine un dígito del primer número, junto con un número entero después de él. Si el espacio es lo suficientemente pequeño, esto eliminará por completo el primer número. De lo contrario, quedará al menos un dígito.

M`1,

Cuente con qué frecuencia 1,aparece en todas las líneas. Si aparece en alguna parte, uno de los pasos era demasiado ancho.

^0

Intente hacer coincidir un número que comience con 0(es decir, solo él 0mismo). Esto es efectivamente una negación lógica de la salida.

JavaScript (ES6), 47 bytes

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

Cómo funciona

Reutilizamos la matriz de entrada apara almacenar la posición de la última aparición encontrada de cada entero a. Usamos la tecla -npara almacenar esta posición para que no interfiera con los índices originales dea .

Cuando a[-n]existe, se produce la prueba real. Cuando a[-n]no existe, la expresión a[-n] - (a[-n] = i)es igual undefined - i == NaNy la comparación con ~nsiempre es falsa, que es el resultado esperado.

Casos de prueba

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 bytes

2 bytes de golf gracias a Martin Ender, que por cierto me presentó a equilibrar grupos con su fantástica guía sobre SO

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

^$

La entrada es una lista separada por comas de números unarios. La salida es 0para falso y 1para verdadero.

Pruébalo en línea! (Conjunto de pruebas que convierte automáticamente de decimal)

Recientemente aprendí sobre el equilibrio de grupos, así que quería probarlos. No se encuentran entre las herramientas más fáciles de usar, pero seguro que son poderosas.

Explicación

$
,$`,

Como hacen muchas otras presentaciones, duplicamos la lista para tratar el ajuste. También agregamos una coma al final, para que cada número sea seguido por una coma (esto hace las cosas un poco más fáciles más adelante)

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

Aquí es donde las cosas se ponen interesantes. Esta es una etapa de reemplazo, reemplazamos todo lo que coincida con la primera línea con la segunda línea, en este caso, buscamos eliminar todos los números nno seguidos porn+1 otros números diferentes.

Para hacerlo, primero hacemos coincidir el número, capturando cada uno 1en un grupo (capturando el grupo número 2 en este caso). Luego, con una anticipación positiva, para tener una afirmación de ancho cero, tratamos repetidamente de hacer coincidir en un grupo de equilibrio -2, que no tendrá éxito más que el número de capturas realizadas por grupo 2, un número seguido de una coma. Después de esta secuencia de números, estamos satisfechos si alcanzamos el primer número nuevamente o el final de la línea.

Nota: esta expresión podría coincidir solo con la parte final de un número, si no logra encontrar una coincidencia con el número completo. Esto no es un problema, porque entonces la primera parte del número permanecerá en la cadena y sabremos que el reemplazo no tuvo éxito por completo.

^$

Finalmente, el resultado debería ser verdadero si eliminamos completamente todos los números de la lista. Intentamos hacer coincidir la cadena vacía y devolver el número de coincidencias encontradas.

Jalea , 11 bytes

ẋ2ĠṢI_2<"QȦ

Pruébalo en línea!

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

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

Pruébalo en línea!

Röda , 50 bytes

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

Pruébalo en línea!

¡Finalmente! He estado esperando para este desafío ...

Es una función que devuelve un valor verdadero o falso. Se necesita un argumento, la matriz.

Se itera sobre una secuencia de índices y verifica para cada índice _1que la distancia del índice actual y el índice siguiente a[_1]no sea mayor que a[_1].

05AB1E , 13 bytes

Dì©v®¦©yky›_P

Pruébalo en línea! o como un conjunto de pruebas

Explicación

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