Sua tarefa é pegar um nelemento nde entrada e saída da Rummy Sequence, uma sequência que eu criei (ver o OEIS não ajudará).

Definição

Cada elemento da sequência Rummy é um conjunto de valores de verdade ou falsey. Ex [true, false]. : .

As etapas para produzir um membro da sequência Rummy são bastante simples:

1. Comece com o primeiro índice [](este é o elemento 0).
2. Defina a falsey mais à esquerda como verdade. Se não houver falseys a serem alterados, aumente o comprimento da lista em 1 e defina todos os membros da nova lista como falsey.
3. Repita a etapa 2 até alcançar o elemento n.

Exemplo

Vamos definir nossa função como rummy(int n)(o material {}é um passo dado para chegar à resposta):

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

Regras

• Aplicam-se brechas padrão.
• Deve funcionar para as entradas 0 através do limite numérico superior do seu idioma.
• Você pode enviar da maneira que achar melhor, desde que fique claro que a saída é um conjunto de verdade / falso.

Curiosidades

Eu chamo isso de "Sequência Rummy" porque, começando no índice 2, define os conjuntos que você precisa estabelecer em cada rodada do Rummy Progressivo , onde a falsey é um livro e a verdade é uma corrida.

Casos de teste

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

Economizou 6 bytes graças a Neil!

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

Eu não acho que isso possa ser jogado mais. Pelo menos com as equações.

Explicação

São duas equações principais ( né entrada):

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

Isso fornecerá o tamanho total da matriz de saída. No meu programa, eu usei, em >>1vez (...)/2disso, são os mesmos que o primeiro bit em binário tem um valor de 2. Mudar resultará emfloor(.../2)

n-a*(a+1)/2

Esta é a quantidade de trues que haverá. aé o resultado da expressão anterior.

Isto é o que a sintaxe faz:

[...Array(n)]

Este código gera uma matriz com intervalo [0, n)nesta resposta né a primeira equação.

.map((_,l)=>l<n)isso passará pelo intervalo acima, lé a variável que contém o item atual no intervalo. Se o item for menor que a quantidade de verdadeiras (determinada pela segunda equação), ele retornará true, caso contrário false.

Python, 51 bytes

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

Produz uma lista de 1 e 0.

Pitão, 8 bytes

_@{y/RQy

Experimente on-line: Demonstration or Test Suite

Isso é exponencialmente lento.

Explicação:

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

Geléia , 13 11 bytes

Ḷṗ2SÞ⁸ị1,0x

O código não funciona na versão mais recente do Jelly antes do lançamento do desafio, mas funcionou nesta versão , que antecede o desafio.

Os índices são baseados em 1. Experimente online! (leva alguns segundos) ou verifique várias entradas ao mesmo tempo .

Como 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ï

Vou ver se consigo jogar um pouco mais e adicionar uma explicação pela manhã.

Experimente online

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

criei meu próprio tipo booleano, o que me permitiu economizar 7 bytes

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

Teste em Ideone .

Python 2, 61 bytes

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

Resolve para n = j · (j + 1) / 2 . A entrada é retirada do stdin.

Uso da amostra

$ 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) , ^{SBCS de} 21 bytes

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

Experimente online!