Dado um número inteiro estritamente positivo n , siga estas etapas:

1. Crie uma matriz A com n 1 s.
2. Se A tiver apenas um elemento, termine. Caso contrário, a partir do primeiro elemento, substituir cada par de A com a sua soma, deixando o último elemento como é se um comprimento 's é estranho, e repita esta etapa.

A saída deve conter um estado 's depois de cada passo, a fim do primeiro passo para o último. É proibido o uso de brechas padrão . Este é um desafio do código-golfe , portanto a solução com o menor número de bytes em cada idioma vence.

Casos de teste

Cada linha na saída desses exemplos é um estado. Você pode imprimir através de qualquer formato razoável.

Entrada: 1

[1]

Entrada: 4

[1, 1, 1, 1]
[2, 2]
[4]

Entrada: 13

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 1]
[8, 5]
[13]

Entrada: 15

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 1]
[4, 4, 4, 3]
[8, 7]
[15]

05AB1E , 7 bytes

Å1Δ=2ôO

Experimente online!

MATL , 10 bytes

:g`t2estnq

Experimente online!

Como funciona

:     % Input n (implicit). Range [1 2 ... n]
g     % Convert to logical. Gives [1 1 ... 1]
`     % Do...while
  t   %   Duplicate
  2   %   Push 2
  e   %   Reshape as 2-column matrix, in column-major order, padding with 0 if needed
  s   %   Sum of each column
  t   %   Duplicate
  n   %   Number of elements
  q   %   Subtract 1. This will be used as loop condition
      % End (implicit). If top of the stack is not zero run new iteration
      % Display stack, bottom to top (implicit)

Python 3 , 57 bytes

def f(i,j=1):print(i//j*[j]+[i%j][:i%j]);i>j and f(i,j*2)

Experimente online!

Python 2 , 51 bytes

def f(i,j=1):print i/j*[j]+[i%j][:i%j];i>j>f(i,j*2)

Experimente online!

-6 bytes no total graças ao tsh

Função recursiva. Para cada etapa, ele constrói uma lista de potências de 2, de modo que a soma seja menor ou igual ao número inteiro especificado. Em seguida, acrescenta o restante, se for maior que 0.

Gelatina , 6 bytes

L€+2/Ƭ

Experimente online!

R , 65 bytes

-1 byte graças a Giuseppe.

n=scan();while(T<2*n){cat(rep(+T,n%/%T),if(n%%T)n%%T,"\n");T=2*T}

Experimente online!

%/%%%k=2^in%/%kkn%%k$2n-1$

Aqui estou usando em Tvez de k, uma vez que é inicializado como o TRUEqual é convertido em 1. Ainda preciso imprimir em +Tvez de Tevitar um vetor de TRUEs na saída.

Pitão , 10 bytes

.u+McN2m1

Experimente online!

.u          # Apply until a result is repeated, return all intermediate steps: lambda N,Y:
  +M        # map by + (reduce list on +):
    cN2     # chop N (current value) into chunks of 2, last one is shorter if needed
       m1Q  # map(1, range(Q)) (implicit Q = input)

-1 byte graças a FryAmTheEggman

JavaScript (V8) , 109 bytes

f=n=>g(Array(n).fill(1));g=(a,i=1)=>{console.log(a);if(a[i]){for(;a[i];)a.splice(i-1,2,a[i-1]+a[i++]);g(a);}}

Experimente online!

Wolfram Language (Mathematica) , 55 54 bytes

Last@Reap[1~Table~#//.a_:>Tr/@Sow@a~Partition~UpTo@2]&

Experimente online!

Finalmente, Sow/ Reapbate uma alternativa!

Retorna uma lista de singleton contendo uma lista das etapas.

K (oK) , 15 17 bytes

{{+/'0N 2#x}\x#1}

Experimente online!

J , 20 bytes

+/\~&_2&.>^:a:@<@#&1

Experimente online!

-2 bytes graças ao Bubbler

Gelatina , 6 bytes

-1 byte graças a Erik, o Outgolfer .

1x+2/Ƭ

Experimente online!

JavaScript, 55 bytes

f=(n,t=1,r=n)=>r>t?t+[,f(n,t,r-t)]:n>t?r+`
`+f(n,t+t):r

Experimente online!

Esta é basicamente a versão básica dos seguintes códigos:

function f(n) {
  var output = '';
  t = 1;
  for (t = 1; ; t *= 2) {
    for (r = n; r > t; r -= t) {
      output += t + ',';
    }
    output += r;
    if (n <= t) break;
    output += '\n';
  }
  return output;
}

Japonês -R , 13 bytes

_ò mx}hUõÎü)â

Tente

Braquilog , 17 bytes

;1j₍ẹẉ₂{ġ₂+ᵐ}ⁱ.ẉȮ

Experimente online!

Como terrivelmente desde que este é, ainda sinto um pouco inteligente para usar .ẉȮ: a maneira mais óbvia para imprimir algo, em seguida, verifique se o seu comprimento é de 1 seria ẉ₂l1, ẉ₂~gou ẉ₂≡Ȯ, onde o ≡na última é necessária porque ẉ₂unifica a sua entrada e saída antes de imprimi-los e Ȯé pré-restringido para ser uma lista de comprimento 1, portanto a unificação falha se a entrada não for uma lista de comprimento 1. No final de um predicado, esse recurso ẉ₂pode ser contornado, no entanto, por usando a variável de saída em vez de assinar ẉ: .ẉȮprimeiro unifica sua entrada com a variável de saída, depois imprime a variável de saída e somente depois unifica a variável de saída com Ȯ.

Stax , 10 bytes

Çë⌐ⁿ┤5π»Å╡

Execute e depure

Procedimento:

1. Gere um intervalo baseado em 0.
2. Divida pela metade cada elemento repetidamente até que todos os itens sejam zero.
3. Calcule os comprimentos de execução para cada matriz exclusiva.

Fonte anotada:

r       main:[0 .. 5] 
{{hmgu  main:[[0 .. 5], [0, 0, 1, 1, 2, 2], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 0]] 
m:GJ    main:"1 1 1 1 1 1" 

Carvão , 19 bytes

ＮθＩＥ↨⊖⊗θ²Ｅ⪪Ｅθ¹Ｘ²κＬλ

Experimente online! Link é a versão detalhada do código. Usa o formato de saída padrão do Charcoal, que é um número por linha, com sub-matrizes com espaçamento duplo. Explicação:

Ｎθ                  Input `n` into a variable
       θ            `n`
      ⊗             Doubled
     ⊖              Decremented
    ↨   ²           Converted to base 2 (i.e. ceil(log2(input)))
   Ｅ                Map
           Ｅθ¹      List of `1`s of length `n`
          ⪪         Split into sublists of length
               ²    Literal `2`
              Ｘ     To power
                κ   Loop index
         Ｅ          Map over each sublist
                 Ｌλ Take the length
  Ｉ                 Cast to string for implicit print

Perl 5 , 46 bytes

say$_="1 "x<>;say while s/(\d+) (\d+)/$1+$2/ge

Experimente online!

A saída é separada por espaço.

Perl 6 , 38 bytes

{1 xx$_,*.rotor(2,:partial)>>.sum...1}

Experimente online!

Há algum atalho para a rotação parcial que eu não estou lembrando agora ...

Explicação:

{                                    }  # Anonymous code block
                                 ...    # Return a sequence
 1 xx$_,            # Starting with a list of 1s with input length
        *           # Where each element is
         .rotor(2,:partial)        # The previous list split into chunks of 2 or less
                           >>.sum  # And each chunk summed
                                    1  # Until the list is length 1

Haskell , 75 bytes

g.pure
g x|x!!0<2=[x]|1>0=(g$(\z->filter(0/=)[-div(-z)2,div z 2])=<<x)++[x]

Experimente online!

Funciona de trás para frente a partir da lista [n]até atingir uma lista de apenas alguns.

Indo para a frente, eu poderia ter 80 bytes utilizando chunksofa partir Data.List.Split:

import Data.List.Split
f x=g$1<$[1..x]
g[n]=[[n]]
g x=x:(g$map sum$chunksOf 2 x)

Experimente online!

Ohm v2 , 8 bytes

@Dv·Ω2σΣ

Experimente online!

Se a saída em notação científica for permitida, caso contrário:

Ohm v2 , 9 bytes

@Dv·Ω2σΣì

Experimente online!

Gaia , 12 bytes

ċ)¦⟨:q2/Σ¦⟩ª

Experimente online!

ċ)¦		| generate array of n 1's (really, generate array of n 0's and increment each)
   ⟨      ⟩ª	| do the following until you get to a fixed point:
    :q		| dup and print with a newline
      2/	| split into groups of 2, with last group possibly being smaller
	Σ¦	| take the sum