Dato un numero intero strettamente positivo n , attenersi alla seguente procedura:

Crea un array A con n 1 s.
Se A ha un solo elemento, termina. Altrimenti, a partire dal primo elemento, sostituire ogni coppia di A con la sua somma, lasciando l'ultimo elemento come se una lunghezza s' è dispari, e ripetere questo passo.

L'output dovrebbe contenere un 's stato dopo ogni passo in ordine dal primo passo all'ultimo. È vietato l' uso di scappatoie standard . Questa è una sfida di code-golf , quindi vince la soluzione con il minor numero di byte in ogni lingua.

Casi test

Ogni riga nell'output di questi esempi è uno stato. È possibile eseguire l'output tramite qualsiasi formato ragionevole.

Ingresso: 1

[1]

Ingresso: 4

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

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

Ingresso: 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 the Outgolfer
fonte

Posso copiare questa domanda per l'ordine inverso? Dato il numero n, uscita graduale A e così via fino a raggiungere n 1 s?

— pixma140,

9

@ pixma140 Sarebbe essenzialmente la stessa sfida, solo con l'uscita invertita in seguito. La modifica è banale.

— Erik the Outgolfer,

6

05AB1E , 7 byte

Å1Δ=2ôO

Provalo online!

— Mr. Xcoder
fonte

4

MATL , 10 byte

:g`t2estnq

Provalo online!

Come funziona

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

4

Python 3 , 57 byte

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

Provalo online!

Python 2 , 51 byte

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

Provalo online!

-6 byte totali grazie a tsh

Funzione ricorsiva. Per ogni passaggio, costruisce un elenco di poteri di 2, in modo tale che la somma sia minore o uguale all'intero dato. Quindi aggiunge il resto, se è maggiore di 0.

— Jitse
fonte

1

Pitone 3 61 byte: 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 byte:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)

— tsh

@tsh Certo, grazie! i>jnon ha funzionato nella mia soluzione precedente e ho dimenticato di provarlo in seguito.

— Jitse,

3

Gelatina , 6 byte

L€+2/Ƭ

Provalo online!

— Jonathan Allan
fonte

3

R , 65 byte

-1 byte grazie a Giuseppe.

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

Provalo online!

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

Qui sto usando Tinvece di k, poiché è inizializzato come TRUEconvertito in 1. Ho ancora bisogno di stampare +Tinvece di Tevitare un vettore di TRUEs nell'output.

— Robin Ryder
fonte

Battimi di circa 5 minuti e quasi 60 byte ... Ma Giuseppe ha ragione, non emette il passaggio finale.

— Sumner18

@ Sumner18 Dovrebbe essere risolto ora.

— Robin Ryder,

+Tè più corto diT+0

— Giuseppe il

@Giuseppe Grazie, sapevo che stavo dimenticando qualcosa.

— Robin Ryder,

3

Pyth , 10 byte

.u+McN2m1

Provalo 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 grazie a FryAmTheEggman

— ar4093
fonte

3

JavaScript (V8) , 109 byte

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

Provalo online!

— AZTECCO
fonte

3

Wolfram Language (Mathematica) , 55 54 byte

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

Provalo online!

~~Infine, Sow/ Reapbatte un'alternativa!~~

Restituisce un elenco singleton contenente un elenco dei passaggi.

— attinat
fonte

3

K (oK) , 15 17 byte

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

Provalo online!

— scarabocchio
fonte

3

J , 20 byte

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

Provalo online!

-2 byte grazie a Gorgogliatore

— Giona
fonte

20 byte eliminando [:e ().

— Bubbler

Bella presa! Grazie.

— Giona

2

Gelatina , 6 byte

-1 byte grazie a Erik the Outgolfer .

1x+2/Ƭ

Provalo online!

— Mr. Xcoder
fonte

2

JavaScript, 55 byte

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

Provalo online!

Questa è fondamentalmente la versione golfata dei seguenti codici:

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
fonte

2

Japt `-R` , 13 byte

_ò mx}hUõÎü)â

Provalo

— ispido
fonte

2

Brachylog , 17 byte

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

Provalo online!

Per quanto terribilmente lungo come questo è, mi sento ancora un po 'intelligente per l'utilizzo .ẉȮ: il modo più ovvio di stampare qualcosa, quindi verificare se la sua lunghezza è 1 sarebbe ẉ₂l1, ẉ₂~go ẉ₂≡Ȯ, dove la ≡nell'ultima è necessaria perché ẉ₂unifica il suo ingresso e uscita prima di stamparli ed Ȯè pre-vincolato a un elenco di lunghezza 1, quindi l'unificazione non riesce se l'input non è un elenco di lunghezza 1. Alla fine di un predicato, questa funzione di ẉ₂può essere aggirata, tuttavia, da utilizzando la variabile di output anziché la sottoscrizione ẉ: .ẉȮprima unifica il suo input con la variabile di output, quindi stampa la variabile di output e solo successivamente unifica la variabile di output con Ȯ.

— Stringa non correlata
fonte

2

Stax , 10 byte

Çë⌐ⁿ┤5π»Å╡

Esegui ed esegui il debug

Procedura:

Genera intervallo basato su 0.
Dividi ripetutamente ogni elemento fino a quando tutti gli elementi sono zero.
Calcola le lunghezze di esecuzione per ciascun array univoco.

Fonte annotata:

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"

— ricorsivo
fonte

1

Carbone , 19 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Utilizza il formato di output predefinito di Charcoal, che è un numero per riga, con subarray a doppia spaziatura l'uno dall'altro. Spiegazione:

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

1

Perl 5 , 46 byte

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

Provalo online!

L'output è separato dallo spazio.

— Xcali
fonte

1

Perl 6 , 38 byte

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

Provalo online!

C'è qualche scorciatoia per il rotore parziale che non ricordo in questo momento ...

Spiegazione:

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

1

Haskell , 75 byte

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

Provalo online!

Funziona all'indietro dall'elenco [n]fino a quando non raggiunge un elenco di solo quelli.

Andando avanti, potrei ottenere 80 byte usando chunksofda 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)

Provalo online!

— Jo King
fonte

0

Ohm v2 , 8 byte

@Dv·Ω2σΣ

Provalo online!

Se è consentito l'output in notazione scientifica, altrimenti:

Ohm v2 , 9 byte

@Dv·Ω2σΣì

Provalo online!

— Cinaski
fonte

Se i numeri di notazione scientifica sono in realtà un tipo di numero naturale (come i float) in Ohm, allora è ragionevole.

— Erik the Outgolfer,

0

Gaia , 12 byte

ċ)¦⟨:q2/Σ¦⟩ª

Provalo 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
fonte

Inizia da quelli

Casi test

05AB1E , 7 byte

MATL , 10 byte

Come funziona

Python 3 , 57 byte

Python 2 , 51 byte

Gelatina , 6 byte

R , 65 byte

Pyth , 10 byte

JavaScript (V8) , 109 byte

Wolfram Language (Mathematica) , 55 54 byte

K (oK) , 15 17 byte

J , 20 byte

Gelatina , 6 byte

JavaScript, 55 byte

Japt -R , 13 byte

Brachylog , 17 byte

Stax , 10 byte

Procedura:

Fonte annotata:

Carbone , 19 byte

Perl 5 , 46 byte

Perl 6 , 38 byte

Spiegazione:

Haskell , 75 byte

Ohm v2 , 8 byte

Ohm v2 , 9 byte

Gaia , 12 byte

Japt `-R` , 13 byte