Étant donné un entier strictement positif n , procédez comme suit:

1. Créez un tableau A avec n 1 s.
2. Si A n'a qu'un seul élément, terminez. Dans le cas contraire, en commençant par le premier élément, remplacer chaque paire de A avec sa somme, la sortie du dernier élément est comme si une longueur d » est impair, et répéter cette étape.

La sortie doit contenir un état de » après chaque étape dans l' ordre depuis la première étape jusqu'à la dernière. L'utilisation de failles standard est interdite. C'est un défi de code-golf , donc la solution avec le moins d'octets dans chaque langue gagne.

Cas de test

Chaque ligne dans la sortie de ces exemples est un état. Vous pouvez sortir via n'importe quel format raisonnable.

Contribution: 1

[1]

Contribution: 4

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

Contribution: 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]

Contribution: 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 octets

Å1Δ=2ôO

Essayez-le en ligne!

MATL , 10 octets

:g`t2estnq

Essayez-le en ligne!

Comment ça fonctionne

:     % 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 octets

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

Essayez-le en ligne!

Python 2 , 51 octets

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

Essayez-le en ligne!

-6 octets au total grâce à tsh

Fonction récursive. Pour chaque étape, il construit une liste de puissances de 2, telle que la somme est inférieure ou égale à l'entier donné. Il ajoute ensuite le reste, s'il est plus grand que 0.

Gelée , 6 octets

L€+2/Ƭ

Essayez-le en ligne!

R , 65 octets

-1 octet grâce à Giuseppe.

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

Essayez-le en ligne!

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

Ici, j'utilise à la Tplace de k, car il est initialisé comme TRUEconverti en 1. J'ai encore besoin d'imprimer +Tau lieu de Tpour éviter un vecteur de TRUEs dans la sortie.

Pyth , 10 octets

.u+McN2m1

Essayez-le en ligne!

.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 octet grâce à FryAmTheEggman

JavaScript (V8) , 109 octets

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

Essayez-le en ligne!

Wolfram Language (Mathematica) , 55 54 octets

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

Essayez-le en ligne!

Finalement, Sow / Reapbat une alternative!

Renvoie une liste singleton contenant une liste des étapes.

K (oK) , 15 17 octets

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

Essayez-le en ligne!

J , 20 octets

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

Essayez-le en ligne!

-2 octets grâce à Bubbler

Gelée , 6 octets

-1 octet grâce à Erik l'Outgolfer .

1x+2/Ƭ

Essayez-le en ligne!

JavaScript, 55 octets

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

Essayez-le en ligne!

Il s'agit essentiellement de la version golfée des codes suivants:

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 octets

_ò mx}hUõÎü)â

Essayez-le

Brachylog , 17 octets

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

Essayez-le en ligne!

Comme horriblement longtemps que cela est, je me sens encore un peu intelligent pour utiliser .ẉȮ: la manière évidente d'imprimer quelque chose, vérifier si sa longueur est de 1 serait ẉ₂l1, ẉ₂~gou ẉ₂≡Ȯ, où ≡la dernière est nécessaire parce que ẉ₂unifie son entrée et sortie avant de les imprimer, et Ȯest pré-contrainte à être une liste de longueur 1, donc l'unification échoue si l'entrée n'est pas une liste de longueur 1. À la fin d'un prédicat, cette caractéristique de ẉ₂peut être contournée, cependant, par en utilisant la variable de sortie au lieu de l'indice ẉ: d' .ẉȮabord unifie son entrée avec la variable de sortie, puis imprime la variable de sortie, puis unifie ensuite la variable de sortie avec Ȯ.

Stax , 10 octets

Çë⌐ⁿ┤5π»Å╡

Exécuter et déboguer

Procédure:

1. Générez une plage basée sur 0.
2. Réduisez de moitié chaque élément jusqu'à ce que tous les éléments soient à zéro.
3. Calculez les longueurs d'exécution pour chaque tableau unique.

Source annotée:

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" 

Fusain , 19 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Utilise le format de sortie par défaut de Charcoal, qui est un nombre par ligne, avec des sous-réseaux à double espacement les uns des autres. Explication:

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

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

Essayez-le en ligne!

La sortie est séparée par des espaces.

Perl 6 , 38 octets

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

Essayez-le en ligne!

Il y a un raccourci vers la rotation partielle dont je ne me souviens pas pour l'instant ...

Explication:

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

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

Essayez-le en ligne!

Fonctionne à l'envers à partir de la liste [n] jusqu'à ce qu'elle atteigne une liste de seulement ceux-là.

Aller vers l' avant, je pourrais obtenir 80 octets en utilisant chunksofde 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)

Essayez-le en ligne!

Ohm v2 , 8 octets

@Dv·Ω2σΣ

Essayez-le en ligne!

Si la sortie en notation scientifique est autorisée, sinon:

Ohm v2 , 9 octets

@Dv·Ω2σΣì

Essayez-le en ligne!

Gaia , 12 octets

ċ)¦⟨:q2/Σ¦⟩ª

Essayez-le en ligne!

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