Beginnen Sie mit denen

18

Führen Sie die folgenden Schritte aus, wenn Sie eine streng positive Ganzzahl n angeben:

  1. Erstellen Sie ein Array A mit n 1 s.
  2. Wenn A nur ein Element hat, beenden Sie. Ansonsten, beginnend mit dem ersten Element, ersetze jedes Paar von A durch seine Summe, lasse das letzte Element so wie es ist, wenn die Länge von A ungerade ist, und wiederhole diesen Schritt.

Die Ausgabe sollte nach jedem Schritt vom ersten bis zum letzten Schritt den Status von A enthalten . Die Verwendung von Standardlücken ist untersagt. Dies ist eine Code-Golf- Herausforderung, daher gewinnt die Lösung mit den wenigsten Bytes in jeder Sprache.

Testfälle

Jede Zeile in der Ausgabe dieser Beispiele ist ein Zustand. Sie können in jedem vernünftigen Format ausgeben.

Eingang: 1

[1]

Eingang: 4

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

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

Eingang: 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 der Outgolfer
quelle
Kann ich diese Frageidee für die umgekehrte Reihenfolge kopieren? Bei gegebener Zahl n wird schrittweise A ausgegeben und so weiter, bis Sie n 1s erreichen?
— Pixma140
9
@ pixma140 Das wäre im Wesentlichen die gleiche Herausforderung, nur mit der Ausgabe danach umgekehrt. Die Änderung ist trivial.
— Erik der Outgolfer

Antworten:

4

MATL , 10 Bytes

:g`t2estnq

Probieren Sie es online!

Wie es funktioniert

:     % 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
quelle
4

Python 3 , 57 Bytes

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

Probieren Sie es online!

Python 2 , 51 Bytes

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

Probieren Sie es online!

-6 bytes gesamt dank tsh

Rekursive Funktion. Für jeden Schritt wird eine Liste der Potenzen von erstellt 2, sodass die Summe kleiner oder gleich der angegebenen Ganzzahl ist. Der Rest wird dann angehängt, wenn er größer als ist 0.

— Jitse
quelle
1
Python 3 61 Bytes 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 Bytes:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)
— tsh
@tsh Natürlich danke! i>jhat in meiner vorherigen Lösung nicht funktioniert und ich habe vergessen, es danach zu versuchen.
— Jitse
3

R , 65 Bytes

-1 Byte danke an Giuseppe.

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

Probieren Sie es online!

%/%%%k=2^in%/%kkn%%k2n-1

Hier verwende ich Tstattdessen k, da es so initialisiert TRUEist, dass es in 1 konvertiert wird. Ich muss trotzdem drucken, +Tanstatt Teinen Vektor von TRUEs in der Ausgabe zu vermeiden .

— Robin Ryder
quelle
Schlage mich um ungefähr 5 Minuten und fast 60 Bytes ... Aber Giuseppe hat recht, er gibt den letzten Schritt nicht aus.
— Sumner,
@ Sumner18 Sollte jetzt behoben sein.
— Robin Ryder
+Tist kürzer alsT+0
— Giuseppe
@ Giuseppe Danke, ich wusste, dass ich etwas vergessen habe.
— Robin Ryder
3

Pyth , 10 Bytes

.u+McN2m1

Probieren Sie es 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 dank FryAmTheEggman

— ar4093
quelle
2

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

Probieren Sie es online!

Dies ist im Grunde die Golfversion der folgenden Codes:

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

Brachylog , 17 Bytes

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

Probieren Sie es online!

So furchtbar lang dies ist, ich fühle mich immer noch ein bisschen schlau für die Verwendung .ẉȮ: die offensichtliche Art, etwas zu drucken, dann überprüfe, ob seine Länge 1 ẉ₂l1ist ẉ₂~g, oder ob ẉ₂≡Ȯdie ≡in der letzten notwendig ist, weil sie ẉ₂ihre Eingabe und Ausgabe vereint bevor er druckt sie und Ȯwird vorab mit beschränktem eine Liste der Länge 1 zu sein , so scheitert die Einigung , wenn der Eingang 1. Am Ende eines Prädikats nicht eine Liste der Länge ist, ist diese Funktion von ẉ₂kann jedoch umgangen werden, indem man Verwenden der Ausgabevariablen anstelle von Subskription ẉ: .ẉȮVereinheitlicht zuerst ihre Eingabe mit der Ausgabevariablen, druckt dann die Ausgabevariable und vereinheitlicht anschließend die Ausgabevariable mit Ȯ.

— Nicht verwandte Zeichenfolge
quelle
2

Stax , 10 Bytes

Çë⌐ⁿ┤5π»Å╡

Führen Sie es aus und debuggen Sie es

Verfahren:

  1. 0-basierten Bereich generieren.
  2. Halbieren Sie jedes Element wiederholt, bis alle Elemente Null sind.
  3. Berechnen Lauflängen für jede eindeutige Array.

Kommentierte Quelle:

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"
— rekursiv
quelle
1

Holzkohle , 19 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Verwendet das Standardausgabeformat von Charcoal (eine Zahl pro Zeile), wobei die Subarrays einen doppelten Abstand voneinander haben. Erläuterung:

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

Perl 6 , 38 Bytes

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

Probieren Sie es online!

Es gibt eine Abkürzung zum partiellen Rotoring, an die ich mich momentan nicht erinnere ...

Erläuterung:

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

Probieren Sie es online!

Funktioniert rückwärts von der Liste [n] bis eine Liste mit nur einer Liste erreicht ist.

Wenn ich vorwärts gehe, könnte ich 80 Bytes erhalten, indem ich verwende chunksofvon 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)

Probieren Sie es online!

— Scherzen
quelle
0

Gaia , 12 Bytes

ċ)¦⟨:q2/Σ¦⟩ª

Probieren Sie es 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
— Giuseppe
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.