La secuencia cíclica de dígitos pares, con probabilidades intermedias

13

Considere la siguiente secuencia:

1, 0, 1, 2, 4, 1, 6, 8, 0, 1, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 0, 1, ...

Los dígitos pares comienzan desde 0 y se agrupan en series de longitud creciente. Se organizan cíclicamente, lo que significa que se ordenan en orden ascendente hasta alcanzar 8 y luego se vuelven a poner en ciclo desde 0 . 1 separa las corridas de dígitos pares, y también comienza la secuencia. Visualicemos cómo se forma esta secuencia:

                 1, 0, 1, 2, 4, 1, 6, 8, 0, 1, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 1,  ...

                    -     ----     -------     ----------     -------------
run length:         1      2          3            4                5            ...
position of 1:   X     X        X           X              X                 X   ...
even sequence:      0,    2, 4,    6, 8, 0,    2, 4, 6, 8,    0, 2, 4, 6, 8      ...

Métodos de entrada y salida aceptables:

  • Recibe un número entero N como entrada y salida de la N º término de esta secuencia.

  • Reciba un entero N como entrada y salida de los primeros N términos de esta secuencia.

  • Imprime la secuencia indefinidamente.

Puede elegir 0 o 1 indexación para los dos primeros métodos.

Puede competir en cualquier lenguaje de programación , mientras usa los métodos estándar de entrada y salida . Las lagunas estándar están prohibidas. Este es el , por lo que gana el código más corto en cada idioma.

Sr. Xcoder
fuente
Este desafío ha sido protegido .
Sr. Xcoder

Respuestas:

8

Haskell , 50 46 bytes

1#cycle[0,2..8]
n#r=1:take n r++(n+1)#drop n r

Pruébalo en línea!

1#cycle[0,2..8] devuelve la secuencia como lista infinita.

-4 bytes gracias a Ørjan Johansen!

Laikoni
fuente
1
Puede guardar cuatro bytes haciendo el primer argumento de #solo un número. Pruébalo en línea!
Ørjan Johansen
7

Jalea , 10 bytes

5ḶḤṁR€1pFḣ

Devuelve el primero n elementos de la secuencia.

Pruébalo en línea!

Cómo funciona

5ḶḤṁR€1pFḣ  Main libk. Argument: n

5           Set the return value to 5.
 Ḷ          Unlength; yield [0, 1, 2, 3, 4].
  Ḥ         Unhalve; yield [0, 2, 4, 6, 8].
    R€      Range each; yield [[1], [1, 2], [1, 2, 3], ..., [1, ..., n]].
   ṁ        Mold; in the result to the left, replace [1] with [0], [1, 2] with
            [2, 4], [1, 2, 3] with [6, 8, 0], and so forth.
      1p    Take the Cartesian product of [1] and the result.
        F   Flatten the result.
         ḣ  Head; take the first n items of the result.
Dennis
fuente
2
ಠ_ಠ Unhalve... ¿No es eso justo Double?
Sr. Xcoder
44
Es solo un mnemotécnico. Hes la mitad , por lo que es unhalve . ÆAes arcocosina , por lo que ÆẠes unarccosina .
Dennis
6

Casco , 12 11 10 bytes

ṁ:1CN¢mDŀ5

Pruébalo en línea!

Imprime la secuencia indefinidamente.

Alternativamente:

J1CΘN¢mDŀ5

Pruébalo en línea!

Explicación

        ŀ5   Start from [0, 1, 2, 3, 4]
      mD     Double each value to get [0, 2, 4, 6, 8]
     ¢       Repeat this list indefinitely, [0, 2, 4, 6, 8, 0, 2, ...]
   CN        Cut it into chunks of increasing lengths, 
             [[0], [2, 4], [6, 8, 0], ...]
ṁ:1          Prepend 1 to each sublist and concate the resulting lists.

Para la solución alternativa:

     ¢mDŀ5   Again, get [0, 2, 4, 6, 8, 0, 2, ...].
  CΘN        This time we prepend a zero to the natural numbers, which
             prepends an empty list to the resulting chunks.
J1           Join all the sublists with 1.

También podríamos hacerlo ...ΘCN..., porque Θ"antepone el elemento predeterminado", que antepone un cero para las listas de enteros y una lista vacía para las listas de listas.

Martin Ender
fuente
4

Python 3 , 52 bytes

def f(n):t=(8*n+1)**.5+1;return 0==t%1or(n-t//2)%5*2

Toma un índice basado en 1 y devuelve True o un flotante integral .

Pruébalo en línea!

Dennis
fuente
2

APL, 25 bytes

Devuelve el enésimo término.

1,(⌽n↑⌽(+/⍳n←⎕)⍴0,2×⍳4),1

Explicación

n←⎕     Prompts for screen input of integer
+/⍳      Creates a vector of integers of 1 to n and sums
⍴0,2×⍳4  Creates a vector by replicating 0 2 4 6 8 to the length of sum
⌽n↑⌽   Rotates the vector, selects first n elements and rotates result
        (selects last n elements}    
1,...,1 Concatenates 1s in front and behind result
Graham
fuente
2

APL (Dyalog Unicode) , 52 59 56 bytes

rc k
r←~n0
:For j :In k
n+←j-1
r,←1,⍨jn0,2×⍳4
:End
rkr

Pruébalo en línea!

Este es un tradfn ( trad itional f unctio n ) teniendo un argumento ky devolver la primerak elementos de la secuencia.

Gracias a @GalenIvanov por señalar un error en la función. Gracias a @ Adám por 3 bytes.

Cómo funciona:

rc k              The function c takes the argument k and results in r
r n1 0            Initializing the variables r and n, and setting them to 1 and 0, respectively.
:For j :In k      For loop. k yields [1, 2, 3, ..., k], and j is the control variable.
n+←j-1             Accumulates j-1 into n, so it follows the progression (0, 1, 3, 6, 10, 15...)
r,←1,⍨jn0,2×⍳4   This line is explained below.
:End               Ends the loop
rkr              return the first k items of r.
                    actually reshapes the vector r to the shape of k;
                   since k is a scalar,  reshapes r to a vector with k items.
            2×⍳4   APL is 1-indexed by default, so this yields the vector 2 4 6 8
          0,       Prepend a 0 to it. We now have 0 2 4 6 8
        n         Rotate the vector n times to the left.
      j           Reshape it to have j items, which cycles the vector.
   1,⍨             Append a 1, then
r,←                Append everything to r.

A continuación se presentan Dfn( d directo teléfono f unctio n ) y una función tácito de que también a resolver el reto, tanto amablemente proporcionado por @ ADAM.

J. Sallé
fuente
Estoy interesado en la explicación del tácito vesrion. ¡Gracias!
Galen Ivanov
@GalenIvanov Agregaré uno más tarde hoy.
J. Sallé
Noté que las 3 funciones producen respuestas incorrectas: las subsecuencias siempre comienzan desde 0 después de 1, deben continuar desde el último dígito par de la subsecuencia anterior.
Galen Ivanov el
@GalenIvanov Tienes razón. Veré si puedo arreglarlo y agregaré las explicaciones hoy.
J. Sallé
1

JavaScript (ES6), 62 54 52 bytes

Devuelve el N º término de la secuencia, 0-indexados.

n=>(g=e=>n--?g(e+=k++<l?2:k=!++l):k<l?e%10:1)(k=l=0)

Manifestación

Arnauld
fuente
1

C (gcc), 84 bytes

i;j;f(){for(i=1;;i++){printf("%d ",1);for(j=0;j<i;)printf("%d ",(2*j+++i*i-i)%10);}}

Pruébalo en línea!

Una función ( f()) que imprime la secuencia infinitamente, separada por espacios.

i es la longitud de la ejecución par actual.

j es el índice en el par actual

(2*j+++i*i-i)%10 da el número par correcto, dados i y j (e incrementos j), equivalente a ((j + Tr (i))% 5) * 2, donde Tr (x) es el número triangular x (que es el número de pares números que se han impreso antes de la ejecución actual;

pizzapants184
fuente
77 bytes
ceilingcat
1

Java 8, 96 bytes

v->{for(int i=0,j=-2,k;;i++,System.out.println(1))for(k=0;k++<i;System.out.println(j%=10))j+=2;}

Imprime indefinidamente, cada número en una nueva línea.

Explicación:

Pruébalo aquí.

v->{                               // Method with empty unused parameter and no return-type
  for(int i=0,                     //  Index integer, starting at 1
          j=-2,                    //  Even index integer, starting at -2
          k;                       //  Inner index integer
      ;                            //  Loop (1) indefinitely
                                   //    After every iteration:
       i++,                        //     Increase index `i` by 1
       System.out.println(1))      //     And print a 1
    for(k=0;                       //   Reset index `k` to 0
        k++<i;                     //   Inner loop (2) from 0 to `i`
                                   //     After every iteration:
       System.out.println(j%=10))  //      Set `j` to `j` modulo-10, and print it
      j+=2;                        //    Increase `j` by 2
                                   //   End of inner loop (2) (implicit / single-line body)
                                   //  End of loop (1) (implicit / single-line body)
}                                  // End of method
Kevin Cruijssen
fuente
1

Lote, 85 bytes.

@set/an=%2+1,t=n*-~n/2
@if %t% lss %1 %0 %1 %n%
@cmd/cset/a(%1-n)%%5*2*!!(t-=%1)+!t

Emite el enésimo término de la secuencia. Funciona calculando el siguiente número triangular.

Neil
fuente
1

Perl 5 , 44 bytes

do{say 1;map{say(($r+=2)%10)}0..$i++}while 1

Pruébalo en línea!

Salida infinita

Xcali
fuente
-4 bytes en {...;redo}lugar dedo{...}while 1
Nahuel Fouilleul
1

J , 46 42 40 bytes

-6 bytes gracias a cole

{.({.[:;[:#:&.>2^i.);@(1,&.><;.1)10|2*i.

Emite los primeros N términos de esta secuencia.

Cómo funciona:

10|[:+:i. - genera una lista de longitud N de 0 2 4 6 8 0 2 4 ... Simplemente toma el mod 10 de los elementos duplicados de una lista de enteros que comienzan en 0.

[:;[:#:&.>2^i. - genera una máscara de bits para cortar la lista anterior.

(1 significa inicio): 1 1 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 0 0 ... Encuentra 2 a la potencia de los enteros consecutivos no negativos, los convierte en binarios, aplana el lista y toma solo los primeros N elementos, de modo que la longitud de ambas listas sea la misma.

;@(1,&.><;.1) - divide (corta) la lista de los dígitos pares en sublistas según el mapa de unos y ceros, agrega la sublista a 1 y finalmente aplana la lista resultante

]{. - toma solo los primeros N elementos, eliminando los números adicionales en la lista debido a los 1s agregados.

Pruébalo en línea!

Galen Ivanov
fuente
1
42 Bytes: {.({.[:;[:#:&.>2^i.);@(1,&.><;.1)(10|2*i.). Los cambios que hice fueron usar ganchos y refactorizar el diente derecho de la horquilla para aprovechar el funcionamiento de las horquillas. Me gusta el 2^i.truco Estoy tratando de trabajar en el diente izquierdo del tenedor ahora.
cole
@cole Gracias, necesito aprender a usar los tenedores mejor. Aparentemente el tenedor 2 * i. es mejor que el gancho tapado [: +: i.
Galen Ivanov
1
También puede colocar los parens en el diente derecho (10|2*i.)->10|2*i.
cole
1

Lisp común, 74 bytes

(do((b 1(1+ b))(k -2))(())(print 1)(dotimes(m b)(print(mod(incf k 2)10))))

Pruébalo en línea!

Imprime la secuencia indefinidamente.

Renzo
fuente
0

Protón , 55 bytes

i=0 j=-2while1{for k:0..i print(j=(j+2)%10)print(1)i++}

Pruébalo en línea!

Imprime la secuencia indefinidamente

Hiperneutrino
fuente
ಠ_ಠ ¿Qué es eso, nueva sintaxis? : p i=0 j=-2while1{...
Sr. Xcoder
@ Mr.Xcoder: P -2whilees como Python y while1es porque hice identificadores que no pueden ser una palabra clave seguida de un número
HyperNeutrino
0

Mathematica, 68 bytes

Devuelve el enésimo término

Insert[Join@@Table[{0,2,4,6,8},#^2],1,Array[{(2-#+#^2)/2}&,#]][[#]]&

Pruébalo en línea!

J42161217
fuente
0

JavaScript, 45 bytes

1 indexado:

f=(x,t=0,p=0)=>p<x?f(x-1,t+1,p+t):x-p?x%5*2:1

0 indexado:

g=(x,p=0)=>p<x?g(x-1,p?++t+p:t=1):x-p?x%5*2:1

tsh
fuente
0

bash, 42 bytes

for((;;)){ echo $[i--?r++%5*2:(i=++j)>0];}

o 34 si es válido

echo $[i--?r++%5*2:(i=++j)>0];. $0

pruébalo en línea

Nahuel Fouilleul
fuente