Definicja

Zdefiniuj n- ^tą tablicę sekwencji CURR w następujący sposób.

1. Zacznij od tablicy singletonów A = [n] .

2. Dla każdej liczby całkowitej K w A wymienić wejścia k o k liczb naturalnych, liczy się od 1 do k .

3. Powtórz poprzedni krok n - 1 jeszcze raz.

Na przykład, jeśli n = 3 , zaczynamy od tablicy [3] .

Zastąpić 3 z 1, 2, 3 , w wyniku czego otrzymano [1, 2, 3] .

Teraz zastąpić 1 , 2 i 3 w 1 ; 1, 2 i 1, 2, 3 (odpowiednio), uzyskując [1, 1, 2, 1, 2, 3] .

Na koniec wykonujemy takie same zamiany jak w poprzednim kroku dla wszystkich sześciu liczb całkowitych w tablicy, uzyskując [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . To jest trzecia tablica CURR.

Zadanie

Napisz program funkcji, która na podstawie ściśle dodatniej liczby całkowitej n jako wartości wejściowej oblicza n- ^tą tablicę CURR.

Wynik musi być jakąś płaską listą (i tablicą zwróconą z funkcji, ciągiem znaków reprezentującym składnię tablicy języka, oddzielonymi spacjami itp.).

To jest golf golfowy . Niech wygra najkrótszy kod w bajtach!

Przypadki testowe

 1 -> [1]
 2 -> [1, 1, 2]
 3 -> [1, 1, 1, 2, 1, 1, 2, 1, 2, 3]
 4 -> [1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4]
 5 -> [1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5]
 6 -> [1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6]

Galaretka, 3 bajty

R¡F

Wypróbuj online

Wyjaśnienie

R¡F    Argument n

R      Yield range [1..n]
 ¡     Repeat n times
  F    Flatten the result

Python, 50 bajtów

lambda i:eval("[i "+"for i in range(1,i+1)"*i+"]")

Nadużycie zakresu! Na przykład i=3ciąg znaków do oceny rozwija się do.

[i for i in range(1,i+1)for i in range(1,i+1)for i in range(1,i+1)]

W jakiś sposób, pomimo użycia zmiennej wejściowej funkcji ido wszystkiego, Python wyróżnia każdy indeks iteracji jako należący do osobnego zakresu, tak jakby wyrażenie

[l for j in range(1,i+1)for k in range(1,j+1)for l in range(1,k+1)]

z iwejściem do funkcji.

05AB1E, 6 3 bajty

DFL

Wyjaśniono

D     # duplicate input
 F    # input times do
  L   # range(1,N)

Wypróbuj online

Zaoszczędź 3 bajty dzięki @Adnan

Siatkówka , 33 bajty

$
$.`$*0
+%(M!&`1.*(?=0)|^.+
O`.+

Wejście i wyjście unary.

Wypróbuj online!

Mimo że nie użyłem zamkniętego formularza do powiązanego wyzwania, dostosowanie tej odpowiedzi było zaskakująco trudne.

Python 2, 82 bajty

lambda n:[1+bin(i)[::-1].find('1')for i in range(1<<2*n-1)if bin(i).count('1')==n]

To nie jest najkrótsze rozwiązanie, ale ilustruje interesującą metodę:

• Zapisz pierwszy 2^(2*n-1) liczby binarnie
• Zachowaj to dokładnie n tymi
• Dla każdej liczby policz liczbę końcowych zer i dodaj 1.

Właściwie 9 bajtów

;#@`♂RΣ`n

Wypróbuj online!

Wyjaśnienie:

;#@`♂RΣ`n
;#@        dupe n, make a singleton list, swap with n
   `♂RΣ`n  call the following function n times:
    ♂R       range(1, k+1) for k in list
      Σ      concatenate the ranges

Dzięki Leaky Nun za bajt i inspirację na kolejne 2 bajty.

C #, 128 bajtów

List<int>j(int n){var l=new List<int>(){n};for(;n>0;n--)l=l.Select(p=>Enumerable.Range(1,p)).SelectMany(m=>m).ToList();return l;

APL, 11 bajtów

{∊⍳¨∘∊⍣⍵+⍵}

Test:

      {∊⍳¨∘∊⍣⍵+⍵} 3
1 1 1 2 1 1 2 1 2 3

Wyjaśnienie:

• +⍵: zaczynając od ⍵,
• ⍣⍵: wykonaj następujące czynności ⍵:
  • ⍳¨∘∊: spłaszcz wejście, a następnie wygeneruj listę [1..N] dla każdego N na wejściu
• ∊: spłaszcz wynik tego

CJam, 14 bajtów

{_a\{:,:~:)}*}

Sprawdź to tutaj.

Wyjaśnienie

_a   e# Duplicate N and wrap it in an array.
\    e# Swap with other copy of N.
{    e# Do this N times...
  :, e#   Turn each x into [0 1 ... x-1].
  :~ e#   Unwrap each of those arrays.
  :) e#   Increment each element.
}*

Mathematica, 27 26 bajtów

1 bajt zapisany z pewną inspiracją z odpowiedzi Essari.

Flatten@Nest[Range,{#},#]&

Dość proste: na wejściu xmamy zacząć {x}, a następnie zastosować Rangedo niej xrazy ( Rangeto Listableco oznacza, że automatycznie odnosi się do liczb całkowitych wewnątrz dowolnie zagnieżdżone listy). Na koniec Flattenwynik.

Clojure, 59 bajtów

(fn[n](nth(iterate #(mapcat(fn[x](range 1(inc x)))%)[n])n))

Wyjaśnienie:

Naprawdę prosty sposób rozwiązania problemu. Praca od wewnątrz:

(1) (fn[x](range 1(inc x))) ;; return a list from 1 to x
(2) #(mapcat (1) %)         ;; map (1) over each item in list and flatten result
(3) (iterate (2) [n])       ;; call (2) repeatedly e.g. (f (f (f [n])))
(4) (nth (3) n))            ;; return the nth value of the iteration

Python 3, 75 74 bajtów

def f(k):N=[k];exec('A=N;N=[]\nfor i in A:N+=range(1,i+1)\n'*k+'print(N)')

To tylko proste tłumaczenie opisu problemu na kod.

Edycja: Zapisano jeden bajt dzięki @Dennis.

R 60 60 bajtów

Dość proste użycie unlisti sapply.

y=x=scan();for(i in 1:x)y=unlist(sapply(y,seq));y

Dzięki @MickyT za zapisanie 11 bajtów

php 121

Nie bardzo przeszkadza w tym podstępem. Spłaszczanie tablicy w php nie jest krótkie, więc najpierw trzeba ją zbudować na płasko

<?php for($a=[$b=$argv[1]];$b--;)$a=array_reduce($a,function($r,$v){return array_merge($r,range(1,$v));},[]);print_r($a);

Haskell, 33 bajty

f n=iterate(>>= \a->[1..a])[n]!!n

Dzięki nim za uratowanie bajtu.

Wersja bez punktów jest dłuższa (35 bajtów):

(!!)=<<iterate(>>= \a->[1..a]).pure

JavaScript (Firefox 30-57), 63 60 bajtów

f=n=>eval(`[${`for(n of Array(n+1).keys())`.repeat(n--)}n+1]`)

Port odpowiedzi na Python @ xnor.

J, 18 bajtów

([:;<@(1+i.)"0)^:]

Proste podejście oparte na procesie opisanym w wyzwaniu.

Stosowanie

   f =: ([:;<@(1+i.)"0)^:]
   f 1
1
   f 2
1 1 2
   f 3
1 1 1 2 1 1 2 1 2 3
   f 4
1 1 1 1 2 1 1 1 2 1 1 2 1 2 3 1 1 1 2 1 1 2 1 2 3 1 1 2 1 2 3 1 2 3 4

Wyjaśnienie

([:;<@(1+i.)"0)^:]  Input: n
                 ]  Identity function, gets the value n
(     ...     )^:   Repeat the following n times with an initial value [n]
      (    )"0        Means rank 0, or to operate on each atom in the list
         i.           Create a range from 0 to that value, exclusive
       1+             Add 1 to each to make the range from 1 to that value
    <@                Box the value
 [:;                  Combine the boxes and unbox them to make a list and return
                    Return the final result after n iterations

Pyth, 8 bajtów

usSMGQ]Q

Wypróbuj online!

usSMGQ]Q   input as Q

u    Q     repeat for Q times,
      ]Q   starting as [Q]:

  SMG          convert each number in the array to its range
 s             flatten

           then implicitly prints the result.

Galaretka, 7 bajtów

Szybko, zanim Dennis odpowie (jk)

WR€F$³¡

Wypróbuj online!

WR€F$³¡  Main monadic chain. Argument: z

W        Yield [z].
     ³¡  Repeat the following z times:
 R€          Convert each number in the array to the corresponding range.
   F         Flatten the array.

F #, 63 bajty

fun n->Seq.fold(fun A _->List.collect(fun k->[1..k])A)[n]{1..n}

Zwraca anonimową funkcję przyjmującą n jako dane wejściowe.

Zastępuje każdy wpis k w A przez [1..k], powtarza proces n razy, zaczynając od A = [n].

Swift 3, 58 bajtów

Przeznaczony do biegania bezpośrednio na placu zabaw, z n ustawionym na wejście

var x=[n];for i in 0..<n{x=x.reduce([]){$0+[Int](1...$1)}}

Bez golfa, z cofnięciem większości notacji krótkiej ręki:

let n = 3 //input

var x: Array<Int> = [n]
for i in 0..<n {
    x = x.reduce(Array<Int>[], combine: { accumulator, element in
        accumulator + Array<Int>(1...element)
    })
}

Java, 159 bajtów

Procedura

int[] q(int y){int z[]=new int[]{y};for(int i=0;i<y;i++){int d=0,a=0;for(int c:z)d+=c;int[]r=new int[d];for(int c:z)for(int j=0;j<c;)r[a++]=++j;z=r;}return z;}

Stosowanie

public static void main(String[] args){String out = "["; int [] b = q(6);for(int c:b)out+=c+", ";System.out.println(out+"]");}

public static int[] q(int y){int z[]=new int[]{y};for(int i=0;i<y;i++){int d=0,a=0;for(int c:z)d+=c;int[]r=new int[d];for(int c:z)for(int j=0;j<c;)r[a++]=++j;z=r;}return z;}

Przykładowe dane wyjściowe:

[1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 1, 2, 1, 1, 2, 1, 2, 3, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, ]

Python 2, 69 68 66 bajtów

def f(n):a=[n];exec'a=sum([range(1,i+1)for i in a],[]);'*n;print a

Edycja: Zapisano 1 bajt dzięki @xnor. Zaoszczędź 2 bajty dzięki @ Dennis ♦.

Narzędzia Bash + GNU, 49

• 1 bajt zapisany dzięki @Dennis.

Funkcje rekurencyjne z potokami FTW!

f()((($1))&&xargs -l seq|f $[$1-1]||dd)
f $1<<<$1

njest przekazywany w wierszu polecenia. Dane wyjściowe są oddzielone znakiem nowej linii.

Zastosowanie ddpowoduje przesłanie statystyk do STDERR. Myślę, że to jest OK, ale jeśli nie, ddmożna je zastąpić catkosztem 1 dodatkowego bajtu.

Perl 5, 53 bajtów

Podprogram:

{($i)=@_;for(1..$i){my@c;push@c,1..$_ for@_;@_=@c}@_}

Zobacz to w akcji jako

perl -e'print "$_ " for sub{($i)=@_;for(1..$i){my@c;push@c,1..$_ for@_;@_=@c}@_}->(3)'

Rubin, 61 bajtów

def f(n);a=[n];n.times{a=a.map{|i|(1..i).to_a}.flatten};a;end

PHP, 100 98 bajtów

Uruchom z php -r '<code>' <n>.

for($a=[$n=$argv[1]];$n--;$a=$b)for($b=[],$k=0;$c=$a[$k++];)for($i=0;$i++<$c;)$b[]=$i;print_r($a);

W każdej iteracji utwórz tymczasową pętlę kopiowania od 1 .. (pierwsza wartość usunięta), aż $abędzie pusta.

Te dwa są nadal i prawdopodobnie pozostaną przy 100 bajtach:

for($a=[$n=$argv[1]];$n--;)for($i=count($a);$i--;)array_splice($a,$i,1,range(1,$a[$i]));print_r($a);

W każdej pętli iteracji do tyłu przez tablicę, zastępując każdą liczbę zakresem.

for($a=[$n=$argv[1]];$n--;)for($i=$c=0;$c=$a[$i+=$c];)array_splice($a,$i,1,range(1,$c));print_r($a);

W każdej pętli iteracji przez tablicę zwiększając indeks o poprzednią liczbę i zastępując każdy indeksowany element zakresem