Su tarea es tomar un nelemento nde entrada y salida de la secuencia rummy, una secuencia que hice (mirar en OEIS no lo ayudará).

Definición

Cada elemento de la secuencia rummy es un conjunto de valores verdaderos o falsos. Ej [true, false]. : .

Los pasos para producir un miembro de la secuencia rummy son bastante simples:

1. Comience con el primer índice, [](este es el elemento 0).
2. Establezca la falsey de la izquierda en veraz Si no hay falseys para cambiar, aumente la longitud de la lista en 1 y configure todos los miembros de la nueva lista en falsey.
3. Repita el paso 2 hasta llegar al elemento n.

Ejemplo

Definamos nuestra función como rummy(int n)(el material {}es un paso para llegar a la respuesta):

>>> rummy(5)
{[]}
{[false]}
{[true]}
{[false, false]}
{[true, false]}
[true, true]

Reglas

• Se aplican lagunas estándar.
• Debe funcionar para las entradas 0 a través del límite numérico superior de su idioma.
• Puede emitir de la forma que considere adecuada, siempre que esté claro que la salida es un conjunto de verdadero / falso.

Trivialidades

Yo llamo a esto la "Secuencia Rummy" porque, comenzando en el índice 2, define los conjuntos que necesitarías establecer en cada ronda de Rummy Progresivo , donde Falsey es un libro y la verdad es una carrera.

Casos de prueba

>>> rummy(0)
[]

>>> rummy(1)
[false]

>>> rummy(6)
[false, false, false]

>>> rummy(20)
[true, true, true, true, true]

>>> rummy(1000)
[true, true, true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]

JavaScript ES6, 94 92 72 70 66 64 bytes

¡Guardado 6 bytes gracias a Neil!

n=>[...Array(a=Math.sqrt(8*n+1)-1>>1)].map((_,l)=>l<n-a*(a+1)/2)

No creo que se pueda jugar más al golf. Al menos con las ecuaciones.

Explicación

Son dos ecuaciones principales ( nes entrada):

(Math.sqrt(8*n+1)-1)/2

Esto le dará el tamaño total que tendrá que ser la matriz de salida. En mi programa, utilicé en >>1lugar de que (...)/2estos sean los mismos, ya que el primer bit en binario tiene un valor de 2. Cambiarlo dará como resultadofloor(.../2)

n-a*(a+1)/2

Esta es la cantidad de trues que habrá. aEs el resultado de la expresión anterior.

Esto es lo que hace la sintaxis:

[...Array(n)]

Este código genera una matriz con rango [0, n)en esta respuesta nes la primera ecuación.

.map((_,l)=>l<n)esto recorrerá el rango anterior, les la variable que contiene el elemento actual en el rango. Si el ítem es menor que la cantidad de verdaderas que son (determinado por la segunda ecuación), entonces regresará true, de lo contrario false.

Python, 51 bytes

f=lambda n,i=0:n>i and f(n+~i,i+1)or[1]*n+[0]*(i-n)

Emite una lista de 1 y 0.

Pyth, 8 bytes

_@{y/RQy

Pruébelo en línea: Demostración o conjunto de pruebas

Esto es exponencialmente lento.

Explicación:

_@{y/RQyQQ    implicit Qs at the end, (Q = input)
       yQ     2*Q
    /RQ       divide each number in [0, 1, ..., 2*Q-1] by Q
              this results in a list of Q zeros and Q ones
   y          take all subsets
  {           remove duplicates
 @       Q    take the Qth element
_             print it reversed

Jalea , 13 11 bytes

Ḷṗ2SÞ⁸ị1,0x

El código no funciona en la última versión de Jelly antes de que se publicara el desafío, pero funcionó en esta versión , que es anterior al desafío.

Los índices están basados ​​en 1. Pruébalo en línea! (toma unos segundos) o verifique múltiples entradas a la vez .

Cómo funciona

Ḷṗ2SÞ⁸ị1,0x  Main link. Argument: n (integer)

Ḷ            Unlength; yield [0, ..., n - 1].
 ṗ2          Take the second Cartesian power, i.e., generate the array of all
             pairs of elements of [0, ..., n - 1].
   SÞ        Sort the pairs by their sum. The sort is stable, so ties are broken
             by lexicographical order.
     ⁸ị      Retrieve the pair at index n.
       1,0x  Map [a, b] to a copies of 1 and b copies of 0.

05AB1E, 27 bytes

8*>t<;ïÐ>*;¹s-ïD1s׊-0s×JSï

Veré si puedo jugar un poco más y agregaré una explicación por la mañana.

Pruébalo en línea

Java, 117 110 bytes

enum B{T,F};B[]r(int n){int i=0,c=0,j=0;while(n>=i)i+=++c;B[]a=new B[c-1];for(;j<n-i+c;)a[j++]=B.T;return a;}

creé mi propio tipo booleano, lo que me permitió guardar 7bytes

Python 2, 69 63 bytes

a=b=0
exec'a,b=[a-1,b+1,0][a<1:][:2];'*input()
print[1]*b+[0]*a

Pruébalo en Ideone .

Python 2, 61 bytes

j=(2*input()+.25)**.5-.5
print[i/j<j%1for i in range(int(j))]

Resuelve para n = j · (j + 1) / 2 . La entrada se toma de stdin.

Uso de muestra

$ echo 20 | python rummy-seq.py
[True, True, True, True, True]

$ echo 50 | python rummy-seq.py
[True, True, True, True, True, False, False, False, False]

Demostración .

APL (Dyalog Extended) , ^{SBCS de} 21 bytes

{⍵⌷↑,/(↓0 1↓⍳≥\⍳)¨⍳⍵}

Pruébalo en línea!