Commencez à partir de ceux

18

É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]
code-golf  arithmetic 
— Erik le Outgolfer
source
Puis-je copier cette idée de questions pour l'ordre inverse? Étant donné le nombre n, sortez pas à pas A, et ainsi de suite jusqu'à ce que vous atteigniez n 1s?
— pixma140
9
@ pixma140 Ce serait essentiellement le même défi, juste avec la sortie inversée par la suite. La modification est triviale.
— Erik the Outgolfer

Réponses:

4

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)
— Luis Mendo
source
4

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.

— Jitse
source
1
Python 3 61 Octets def f(i,j=1):l=i//j*[j]+[i%j][:i%j];print(l);i>j and f(i,j*2); Python 2 55 octets:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)
— tsh
@tsh Bien sûr, merci! i>jn'a pas fonctionné dans ma solution précédente et j'ai oublié de l'essayer par la suite.
— Jitse
3

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%%k2n−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.

— Robin Ryder
source
Battez-moi d'environ 5 minutes et presque 60 octets ... Mais Giuseppe a raison, il ne sort pas la dernière étape.
— Sumner18
@ Sumner18 devrait être corrigé maintenant.
— Robin Ryder
+Test plus court queT+0
— Giuseppe
@Giuseppe Merci, je savais que j'oubliais quelque chose.
— Robin Ryder
3

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

— ar4093
source
2

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;
}
— tsh
source
2

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

— Chaîne indépendante
source
2

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"
— récursif
source
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
— Neil
source
1

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
— Jo King
source
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!

— Jo King
source
0

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
— Giuseppe
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.