Il tuo compito è quello di prendere un nelemento ndi input e output di Rummy Sequence, una sequenza che ho creato (guardare su OEIS non ti aiuterà).

Definizione

Ogni elemento della sequenza Rummy è un insieme di valori di verità o falsità. Es [true, false]. :

I passaggi per produrre un membro della sequenza Rummy sono abbastanza semplici:

1. Inizia con il primo indice, [](questo è l'elemento 0).
2. Imposta la falsità più a sinistra su verità. Se non ci sono falsi da modificare, aumentare la lunghezza dell'elenco di 1 e impostare tutti i membri del nuovo elenco su falso.
3. Ripetere il passaggio 2 fino a raggiungere l'elemento n.

Esempio

Definiamo la nostra funzione come rummy(int n)(roba in {}è un passo fatto per arrivare alla risposta):

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

Regole

• Si applicano scappatoie standard.
• Deve funzionare per gli input 0 attraverso il limite numerico superiore della tua lingua.
• È possibile produrre in qualsiasi modo si ritenga opportuno, purché sia ​​chiaro che l'output è un insieme di verità / falsità.

banalità

La chiamo "Rummy Sequence" perché, a partire dall'indice 2, definisce i set che dovresti stabilire in ogni round di Progressive Rummy , in cui la falsità è un libro e la verità è una corsa.

Casi test

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

6 byte salvati grazie a Neil!

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

Non credo che si possa giocare di più a golf. Almeno con le equazioni.

Spiegazione

Sono due equazioni principali ( nè input):

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

Ciò fornirà la dimensione totale che l'array di output dovrà essere. Nel mio programma che ho usato >>1invece di (...)/2questi sono gli stessi del primo bit in binario ha un valore di 2. Spostandolo si otterràfloor(.../2)

n-a*(a+1)/2

Questa è la quantità di trues che ci sarà. aè il risultato dell'espressione precedente.

Questo è ciò che fa la sintassi:

[...Array(n)]

Questo codice genera un array con intervallo [0, n)in questa risposta nè la prima equazione.

.map((_,l)=>l<n)questo passerà attraverso l'intervallo sopra, lè la variabile che contiene l'elemento corrente nell'intervallo. Se l'oggetto è inferiore alla quantità di verità che sono (determinata dalla seconda equazione), allora ritornerà true, altrimenti false.

Python, 51 byte

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

Emette un elenco di 1 e 0.

Pyth, 8 byte

_@{y/RQy

Provalo online: Dimostrazione o Test Suite

Questo è esponenzialmente lento.

Spiegazione:

_@{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

Gelatina , 13 11 byte

Ḷṗ2SÞ⁸ị1,0x

Il codice non funziona nell'ultima versione di Jelly prima che la sfida fosse pubblicata, ma funzionava in questa versione , che precede la sfida.

Gli indici sono basati su 1. Provalo online! (richiede alcuni secondi) o verifica più input contemporaneamente .

Come funziona

Ḷṗ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 byte

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

Vedrò se posso giocare a golf ancora un po 'e aggiungere una spiegazione al mattino.

Provalo online

Java, 117 110 byte

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

creato il mio tipo booleano, che mi ha permesso di salvare 7 byte

Python 2, 69 63 byte

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

Provalo su Ideone .

Python 2, 61 byte

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

Risolve per n = j · (j + 1) / 2 . L'input è preso dallo stdin.

Esempio di utilizzo

$ 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]

Demo .

APL (Dyalog Extended) , 21 byte ^SBCS

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

Provalo online!