Dado un número estrictamente positivo n , siga estos pasos:

1. Cree una matriz A con n 1 s.
2. Si A solo tiene un elemento, finalice. De lo contrario, a partir del primer elemento, reemplazar cada par de A con su suma, dejando el último elemento como es si A longitud 's es impar, y repetir este paso.

La salida debe contener un estado 's después de cada paso en orden desde la primera etapa hasta la última. El uso de lagunas estándar está prohibido. Este es un desafío de código de golf , por lo que gana la solución con la menor cantidad de bytes en cada idioma.

Casos de prueba

Cada línea en la salida de estos ejemplos es un estado. Puede enviar a través de cualquier formato razonable.

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

Pruébalo en línea!

MATL , 10 bytes

:g`t2estnq

Pruébalo en línea!

Cómo 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)

Pruébalo en línea!

Python 2 , 51 bytes

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

Pruébalo en línea!

-6 bytes en total gracias a tsh

Función recursiva. Para cada paso, construye una lista de potencias de 2tal manera que la suma es menor o igual que el entero dado. Luego agrega el resto, si es más grande que 0.

Jalea , 6 bytes

L€+2/Ƭ

Pruébalo en línea!

R , 65 bytes

-1 byte gracias a Giuseppe.

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

Pruébalo en línea!

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

Aquí estoy usando en Tlugar de k, ya que se inicializa como TRUEque se convierte a 1. Todavía necesito imprimir en +Tlugar de Tevitar un vector de TRUEs en la salida.

Pyth , 10 bytes

.u+McN2m1

Pruébalo en línea!

.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 gracias 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);}}

Pruébalo en línea!

Wolfram Language (Mathematica) , 55 54 bytes

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

Pruébalo en línea!

Por último, Sow/ Reaplate una alternativa!

Devuelve una lista singleton que contiene una lista de los pasos.

K (oK) , 15 17 bytes

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

Pruébalo en línea!

J , 20 bytes

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

Pruébalo en línea!

-2 bytes gracias a Bubbler

Jalea , 6 bytes

-1 byte gracias a Erik the Outgolfer .

1x+2/Ƭ

Pruébalo en línea!

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

Pruébalo en línea!

Esta es básicamente la versión de golf de los siguientes 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;
}

Japt -R , 13 bytes

_ò mx}hUõÎü)â

Intentalo

Brachylog , 17 bytes

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

Pruébalo en línea!

Como terriblemente larga, ya que es, todavía me siento un poco inteligente para el uso .ẉȮ: la manera obvia para imprimir algo, a continuación, comprobar si su longitud es 1 sería ẉ₂l1, ẉ₂~go ẉ₂≡Ȯ, en el ≡en el último es necesario porque ẉ₂unifica su entrada y salida antes de imprimirlos, y Ȯestá restringido previamente a ser una lista de longitud 1, por lo que la unificación falla si la entrada no es una lista de longitud 1. ẉ₂Sin embargo, al final de un predicado, esta característica de se puede eludir usando la variable de salida en lugar de suscribir ẉ: .ẉȮprimero unifica su entrada con la variable de salida, luego imprime la variable de salida y solo después unifica la variable de salida con Ȯ.

Stax , 10 bytes

Çë⌐ⁿ┤5π»Å╡

Ejecutar y depurarlo

Procedimiento:

1. Generar rango basado en 0.
2. Reduzca a la mitad cada elemento hasta que todos los elementos sean cero.
3. Calcule las longitudes de ejecución para cada matriz única.

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

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Utiliza el formato de salida predeterminado de Charcoal, que es un número por línea, con submatrices a doble espacio entre sí. Explicación:

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

Pruébalo en línea!

La salida está separada por espacios.

Perl 6 , 38 bytes

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

Pruébalo en línea!

Hay un atajo para la rotura parcial que no recuerdo en este momento ...

Explicación:

{                                    }  # 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]

Pruébalo en línea!

Trabaja al revés de la lista [n] hasta que alcanza una lista de solo unos.

Yendo hacia delante, que podría conseguir 80 bytes usando chunksofdesde 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)

Pruébalo en línea!

Ohm v2 , 8 bytes

@Dv·Ω2σΣ

Pruébalo en línea!

Si se permite la salida en notación científica, de lo contrario:

Ohm v2 , 9 bytes

@Dv·Ω2σΣì

Pruébalo en línea!

Gaia , 12 bytes

ċ)¦⟨:q2/Σ¦⟩ª

Pruébalo en línea!

ċ)¦		| 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