Kesinlikle pozitif bir tamsayı n verildiğinde şu adımları izleyin:

1. N 1 s ile A dizisi oluşturun .
2. Eğer bir tek eleman vardır, sonlandırmak. Aksi takdirde, ilk elemandan başlayarak, her A çiftini toplamıyla değiştirin, son elemanı A'nın uzunluğu garipmiş gibi bırakın ve bu adımı tekrarlayın.

Çıktı , ilk adımdan sonuncuya doğru her adımdan sonra A'nın durumunu içermelidir . Kullanımı standart boşluklar yasaktır. Bu bir kod golf zorluğudur, bu nedenle her dilde en az bayt içeren çözüm kazanır.

Test senaryoları

Bu örneklerin çıktısındaki her satır bir durumdur. Herhangi bir makul formatta çıktı alabilirsiniz.

Giriş: 1

[1]

Giriş: 4

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

Giriş: 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]

Giriş: 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 bayt

Å1Δ=2ôO

Çevrimiçi deneyin!

MATL , 10 bayt

:g`t2estnq

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Python 2 , 51 bayt

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

Çevrimiçi deneyin!

Tsh sayesinde toplam -6 bayt

Özyinelemeli işlev. Her adım için, 2toplamın verilen tamsayıdan daha küçük veya ona eşit olacak şekilde bir güç listesi oluşturur . Daha sonra, daha büyükse kalanını ekler 0.

Jöle , 6 bayt

L€+2/Ƭ

Çevrimiçi deneyin!

R, , 65 bayt

Giuseppe sayesinde -1 bayt.

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

Çevrimiçi deneyin!

Özyinelemeyi önler. R de %/%, tamsayı bölümüdür ve %%modülodur. 2'nin her gücü k=2^iiçin n%/%k, değerin katlarını yazdırmamız gerekir kve sonra n%%kbu değer sıfır değilse. Bunu küçük 2 güç için yapın$2n-1$ .

Burada Tyerine kullanıyorum k, çünkü TRUE1'e dönüştürüldüğü gibi başlatıldı. Hala +Tbunun yerine yazdırmam gerekiyorTTRUE Çıktıda bir s vektöründen kaçınmak .

Pyth , 10 bayt

.u+McN2m1

Çevrimiçi deneyin!

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

FryAmTheEggman sayesinde -1 bayt

JavaScript (V8) , 109 bayt

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

Çevrimiçi deneyin!

Wolfram Dili (Mathematica) , 55 54 bayt

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

Çevrimiçi deneyin!

Son olarak, Sow/ Reapalternatifi yener!

Adımların listesini içeren tek bir liste döndürür.

K (oK) , 15 17 bayt

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

Çevrimiçi deneyin!

J , ²⁰ 17 bayt

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

Çevrimiçi deneyin!

Bubbler sayesinde -5 bayt

Jöle , 6 bayt

Outgolfer Erik sayesinde -1 bayt .

1x+2/Ƭ

Çevrimiçi deneyin!

JavaScript, 55 bayt

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

Çevrimiçi deneyin!

Bu temelde aşağıdaki kodların golf versiyonudur:

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 bayt

_ò mx}hUõÎü)â

Dene

Brachylog , 17 bayt

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

Çevrimiçi deneyin!

Korkunç uzun bu olduğu kadar, hala kullanmak için akıllı biraz hissetmek .ẉȮ: uzunluğu 1 olacağını ise bariz bir şekilde bir şeyler yazdırmak için, daha sonra kontrol ẉ₂l1, ẉ₂~gya ẉ₂≡Ȯ, nerede ≡sonuncusu gerekli olduğu için ẉ₂birleştirir onun giriş ve çıkış bunları yazdırmadan önce ve Ȯuzunluk 1 listesi olarak önceden kısıtlanmış olduğundan, giriş 1 uzunluk listesi değilse birleşim başarısız olur. Bir yüklemin sonunda, bu özelliğin önüne ẉ₂geçilebilir. abone olmak yerine çıktı değişkenini kullanmak ẉ: .ẉȮönce girdisini çıktı değişkeniyle birleştirir, sonra çıktı değişkenini yazdırır ve daha sonra çıktı değişkenini ile birleştirir Ȯ.

Stax , 10 bayt

Çë⌐ⁿ┤5π»Å╡

Çalıştır ve hata ayıkla

Prosedür:

1. 0 tabanlı aralık oluşturun.
2. Tüm öğeler sıfır oluncaya kadar her öğeyi tekrar tekrar yarıya indirin.
3. Her benzersiz dizi için çalışma uzunluklarını hesaplayın.

Açıklamalı Kaynak:

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" 

Kömür , 19 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Kömürün satır başına bir sayı olan varsayılan çıktı biçimini kullanır ve alt diziler birbirinden çift aralıklıdır. Açıklama:

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

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

Çevrimiçi deneyin!

Çıktı boşlukla ayrılmıştır.

Perl 6 , 38 bayt

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

Çevrimiçi deneyin!

Kısmi rotorlamanın şu an hatırlamadığım bazı kısayolları var ...

Açıklama:

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

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

Çevrimiçi deneyin!

[n]Yalnızca bir listeye ulaşıncaya kadar listeden geriye doğru çalışır .

İleriye giderek, kullanıyorum bayt 80 alabilir chunksofdan 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)

Çevrimiçi deneyin!

Fıçı , 30 bayt

(|1){!1>|^(:. ,")^
,(!2/|+")}.

Çevrimiçi deneyin!

Aslında bu meydan okumayı bir süredir tamamlamak için anlam ifade ettim (yani, kendime bunun bağlantısını e-postayla gönderdim, böylece hatırlıyorum), ama şimdiye kadar bunu yapmadım!

GolfScript , 24 bayt

Çok uzun bir cevap ... okunması zor çıktı formatını kullanarak 1 bayt çıkardı

~[1]*{..2/{{+}*}%\,(}do;

Çevrimiçi deneyin!

açıklama

~                        // Dump the contents of the input string
 [1]*                    // Create a 1-list with the length of the input string
     {              }do  // do ... while
                 \,(     // the length of the array is larger than 1
      .                  // Extra evolution step that we need to keep
       .                 // Create a copy of the input
        2/               // That splits into parts of 2 items
          {    }%        // For each over the splitted array:
           {+}*          // Reduce the item with addition
                         // e.g. [1] -> [1], [1 2] -> [3], etc.
                       ; // Discard the abundant copy

Ohm v2 , 8 bayt

@Dv·Ω2σΣ

Çevrimiçi deneyin!

Bilimsel gösterimde çıktıya izin verilirse, aksi takdirde:

Ohm v2 , 9 bayt

@Dv·Ω2σΣì

Çevrimiçi deneyin!

Gaia , 12 bayt

ċ)¦⟨:q2/Σ¦⟩ª

Çevrimiçi deneyin!

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

APL, 28 karakter

{1≢≢⎕←⍵:∇+/(⌈.5×≢⍵)2⍴⍵,0}⍴∘1

1'ler vektör

⍴∘1

bağımsız değişkeni çıktılayın ve uzunluğun 1'den farklı olup olmadığını kontrol edin: öyleyse devam edin

1≢≢⎕←⍵:

uzunluğunun yarısını alın ve yuvarlayın

⌈.5×≢⍵

gerekirse bir izleyen 0 ekleyerek bir nx2 matrisine yeniden şekillendirin

(⌈.5×≢⍵)2⍴⍵,0

satır satır toplamı

+/

recurse

∇