Давши суворо додатне ціле число n , виконайте наступні кроки:

1. Створіть масив A з n 1 s.
2. Якщо A має лише один елемент, скасуйте. В іншому випадку, починаючи з першого елемента, замініть кожну пару A на її суму, залишивши останній елемент таким же, як і довжина A непарного, і повторіть цей крок.

Вихід повинен містити стан A після кожного кроку в порядку від першого кроку до останнього. Використання стандартних бійниць заборонено. Це проблема з кодовим гольфом , тому рішення з найменшими байтами на кожній мові виграє.

Тестові справи

Кожен рядок у висновку цих прикладів є станом. Ви можете виводити в будь-якому розумному форматі.

Вхід: 1

[1]

Вхід: 4

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

Вхід: 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]

Вхід: 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 байт

Å1Δ=2ôO

Спробуйте в Інтернеті!

MATL , 10 байт

:g`t2estnq

Спробуйте в Інтернеті!

Як це працює

:     % 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 байт

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

Спробуйте в Інтернеті!

Python 2 , 51 байт

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

Спробуйте в Інтернеті!

-6 байт загалом завдяки tsh

Рекурсивна функція. Для кожного кроку він будує перелік потужностей 2, такий, що сума менша або дорівнює заданому цілому числу. Потім додається залишок, якщо він більший за 0.

Желе , 6 байт

L€+2/Ƭ

Спробуйте в Інтернеті!

R , 65 байт

-1 байт завдяки Джузеппе.

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

Спробуйте в Інтернеті!

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

Тут я використовую Tзамість k, оскільки вона ініціалізована як TRUEперетворена в 1. Мені все одно потрібно друкувати +Tзамість того, Tщоб уникнути вектора TRUEs у виході.

Pyth , 10 байт

.u+McN2m1

Спробуйте в Інтернеті!

.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 байт завдяки FryAmTheEggman

JavaScript (V8) , 109 байт

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

Спробуйте в Інтернеті!

Мова Вольфрама (Mathematica) , 55 54 байти

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

Спробуйте в Інтернеті!

Нарешті, Sow/ Reapб'є альтернативу!

Повертає однотонний список, що містить перелік кроків.

K (oK) , 15 17 байт

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

Спробуйте в Інтернеті!

J , ²⁰ 17 байт

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

Спробуйте в Інтернеті!

-5 байт завдяки Bubbler

Желе , 6 байт

-1 байт завдяки Еріку Переможнику .

1x+2/Ƭ

Спробуйте в Інтернеті!

JavaScript, 55 байт

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

Спробуйте в Інтернеті!

Це в основному гольф-версія наступних кодів:

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 байт

_ò mx}hUõÎü)â

Спробуй це

Брахілог , 17 байт

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

Спробуйте в Інтернеті!

Як жахливо довго , як це, я все ще відчуваю себе трохи розумний для використання .ẉȮ: очевидний спосіб надрукувати що - небудь, а потім перевірити , якщо його довжина дорівнює 1 буде ẉ₂l1, ẉ₂~gабо ẉ₂≡Ȯ, де ≡в останньому необхідно тому , що ẉ₂уніфікує його вхід і вихід перш ніж він надрукує їх і Ȯпопередньо обмежений списком довжини 1, тому об'єднання не вдається, якщо введення не є списком довжини 1. В кінці предиката цю функцію ẉ₂можна обійти, однак, використовуючи вихідну змінну замість підписки ẉ: .ẉȮспочатку уніфікує свій вхід із змінною виводу, потім друкує вихідну змінну, і лише після цього уніфікує вихідну змінну Ȯ.

Стакса , 10 байт

Çë⌐ⁿ┤5π»Å╡

Запустіть і налагоджуйте його

Порядок:

1. Створіть діапазон на основі 0.
2. Повторно вдвічі вдвічі зменшуйте кожен елемент, поки всі елементи не дорівнюють нулю.
3. Обчисліть довжини пробігу для кожного унікального масиву.

Анотоване джерело:

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" 

Вугілля деревне , 19 байт

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

Спробуйте в Інтернеті! Посилання на багатослівну версію коду. Використовується вихідний формат деревного вугілля, який становить одне число на рядок, з підрядами, подвійними відстані один від одного. Пояснення:

Ｎθ                  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 байт

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

Спробуйте в Інтернеті!

Вихід розділений пробілом.

Perl 6 , 38 байт

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

Спробуйте в Інтернеті!

Є деякий ярлик до часткового обертання, якого я зараз не пам’ятаю ...

Пояснення:

{                                    }  # 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 байт

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

Спробуйте в Інтернеті!

Працює назад від списку [n]до тих пір, поки не потрапить до списку лише таких.

Йдучи вперед, я міг би отримати 80 байт , використовуючи chunksofвід 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)

Спробуйте в Інтернеті!

Кег , 30 байт

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

Спробуйте в Інтернеті!

Я насправді мав намір на деякий час виконати цю проблему (я маю на увазі, я надіслав електронною поштою посилання на неї, щоб я пам’ятав), але я ніколи не доводився робити це до цих пір!

GolfScript , 24 байти

Жахливо довга відповідь ... вийшов 1 байт, використовуючи важко читаний вихідний формат

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

Спробуйте в Інтернеті!

Пояснення

~                        // 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

Ом v2 , 8 байт

@Dv·Ω2σΣ

Спробуйте в Інтернеті!

Якщо вихід у наукові позначення дозволений, інакше:

Ом v2 , 9 байт

@Dv·Ω2σΣì

Спробуйте в Інтернеті!

Гая , 12 байт

ċ)¦⟨:q2/Σ¦⟩ª

Спробуйте в Інтернеті!

ċ)¦		| 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 символів

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

вектор 1s

⍴∘1

виведіть аргумент і перевірте, чи довжина інша, ніж 1: якщо так, продовжуйте

1≢≢⎕←⍵:

отримати половину довжини і округлити

⌈.5×≢⍵

переформатуйте в матрицю nx2, додавши, якщо потрібно, кінцевий 0

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

сума рядка за рядком

+/

рецидивувати

∇