Zacznij od nich

18

Biorąc pod uwagę ściśle dodatnią liczbę całkowitą n , wykonaj następujące kroki:

  1. Utwórz tablicę A za pomocą n 1 s.
  2. Jeśli A ma tylko jeden element, zakończ. W przeciwnym wypadku, począwszy od pierwszego elementu, wymienić każdą parę A z sumy, pozostawiając ostatni element jak gdyby długość jest to dziwne, i powtórzyć tę czynność.

Dane wyjściowe powinny zawierać stan A po każdym kroku w kolejności od pierwszego do ostatniego kroku. Korzystanie ze standardowych luk jest zabronione. Jest to wyzwanie dla golfisty , więc wygrywa rozwiązanie z najmniejszą liczbą bajtów w każdym języku.

Przypadki testowe

Każda linia w wynikach tych przykładów jest stanem. Możesz drukować w dowolnym rozsądnym formacie.

Wejście: 1

[1]

Wejście: 4

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

Wejście: 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]

Wejście: 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
źródło
Czy mogę skopiować ten pomysł na pytania w odwrotnej kolejności? Biorąc pod uwagę liczbę n, wypisz krok A i tak dalej, aż dojdziesz do n 1s?
— pixma140
10
@ pixma140 To byłoby zasadniczo to samo wyzwanie, tylko z odwróconą produkcją. Modyfikacja jest trywialna.
— Erik the Outgolfer

Odpowiedzi:

4

MATL , 10 bajtów

:g`t2estnq

Wypróbuj online!

Jak to działa

:     % 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
źródło
4

Python 3 , 57 bajtów

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

Wypróbuj online!

Python 2 , 51 bajtów

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

Wypróbuj online!

-6 bajtów ogółem dzięki tsh

Funkcja rekurencyjna. Dla każdego kroku konstruuje listę potęg 2takich, że suma jest mniejsza lub równa podanej liczbie całkowitej. Następnie dołącza resztę, jeśli jest większa niż 0.

— Jitse
źródło
1
Pyton 3 61 bajtów: 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 bajtów:def f(i,j=1):l=i/j*[j]+[i%j][:i%j];print l;i>j>f(i,j*2)
— tsh
@tsh Oczywiście, dziękuję! i>jnie działało w moim poprzednim rozwiązaniu i zapomniałem go później wypróbować.
— Jitse,
3

R , 65 bajtów

-1 bajt dzięki Giuseppe.

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

Wypróbuj online!

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

Tutaj używam Tzamiast k, ponieważ jest on inicjalizowany, ponieważ TRUEjest konwertowany na 1. Nadal muszę drukować +Tzamiast Tunikać wektora TRUEs na wyjściu.

— Robin Ryder
źródło
Pokonaj mnie o około 5 minut i prawie 60 bajtów ... Ale Giuseppe ma rację, nie generuje ostatniego kroku.
— Sumner18,
@ Sumner18 Należy teraz naprawić.
— Robin Ryder
+Tjest krótszy niżT+0
— Giuseppe
@Giuseppe Dzięki, wiedziałem, że o czymś zapomniałem.
— Robin Ryder
3

Pyth , 10 bajtów

.u+McN2m1

Wypróbuj 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 bajt dzięki FryAmTheEggman

— ar4093
źródło
2

JavaScript, 55 bajtów

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

Wypróbuj online!

Jest to w zasadzie golfowa wersja następujących kodów:

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
źródło
2

Brachylog , 17 bajtów

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

Wypróbuj online!

Jak strasznie długo, jak to jest, nadal czuję się trochę mądrego korzystania .ẉȮ: oczywistym sposobem coś wydrukować, a następnie sprawdzić, czy jego długość wynosi 1 byłoby ẉ₂l1, ẉ₂~glub ẉ₂≡Ȯ, w przypadku gdy ≡w ostatnim z nich jest konieczne, ponieważ ẉ₂jednoczy jego wejście i wyjście przed wydrukowaniem ich i Ȯjest wstępnie ograniczony do listy o długości 1, więc unifikacja kończy się niepowodzeniem, jeśli dane wejściowe nie są listą o długości 1. Na końcu predykatu ẉ₂można ominąć tę cechę używając zmiennej wyjściowej zamiast subskrybowania ẉ: .ẉȮnajpierw ujednolica dane wejściowe ze zmienną wyjściową, następnie drukuje zmienną wyjściową, a dopiero potem ujednolica zmienną wyjściową z Ȯ.

— Niepowiązany ciąg
źródło
2

Stax , 10 bajtów

Çë⌐ⁿ┤5π»Å╡

Uruchom i debuguj

Procedura:

  1. Wygeneruj zakres oparty na 0.
  2. Kilkakrotnie zmniejszaj o połowę każdy element, aż wszystkie elementy osiągną zero.
  3. Oblicz przebiegi dla każdej unikalnej tablicy.

Źródło adnotacji:

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"
— rekurencyjny
źródło
1

Węgiel drzewny , 19 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Używa domyślnego formatu wyjściowego Charcoal, który jest jedną liczbą w wierszu, z podwójnymi odstępami między nimi. Wyjaśnienie:

Ｎθ                  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
źródło
1

Perl 6 , 38 bajtów

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

Wypróbuj online!

Istnieje skrót do częściowego wirowania, którego teraz nie pamiętam ...

Wyjaśnienie:

{                                    }  # 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
źródło
1

Haskell , 75 bajtów

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

Wypróbuj online!

Działa wstecz z listy [n] aż osiągnie listę tylko tych.

Idąc do przodu, mogę dostać 80 bajtów korzystania chunksofz 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)

Wypróbuj online!

— Jo King
źródło
1

Keg , 30 bajtów

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

Wypróbuj online!

Przez pewien czas miałem zamiar ukończyć to wyzwanie (mam na myśli, że wysłałem sobie link do niego, aby zapamiętać), ale do tej pory nigdy tego nie zrobiłem!

— Jono 2906
źródło
1

GolfScript , 24 bajty

Strasznie długa odpowiedź ... odegrał 1 bajt, używając trudnego do odczytania formatu wyjściowego

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

Wypróbuj online!

Wyjaśnienie

~                        // 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
— za'_'
źródło
0

Gaia , 12 bajtów

ċ)¦⟨:q2/Σ¦⟩ª

Wypróbuj 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
źródło
0

APL, 28 znaków

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

wektor 1s

⍴∘1

wypisz argument i sprawdź, czy długość jest inna niż 1: jeśli tak, kontynuuj

1≢≢⎕←⍵:

dostać połowę długości i zaokrąglić w górę

⌈.5×≢⍵

przekształć w macierz nx2, dodając końcowe 0, jeśli to konieczne

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

suma rząd po rzędzie

+/

powrócić

∇
— Popow
źródło
— Popov
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.