Definisi

Tentukan susunan ^ke- n dari urutan CURR sebagai berikut.

1. Mulailah dengan array singleton A = [n] .

2. Untuk setiap bilangan bulat k di A , menggantikan masuk k dengan k bilangan, menghitung naik dari 1 ke k .

3. Ulangi langkah sebelumnya n - 1 kali lagi.

Misalnya, jika n = 3 , kita mulai dengan array [3] .

Kami mengganti 3 dengan 1, 2, 3 , menghasilkan [1, 2, 3] .

Kami sekarang mengganti 1 , 2 , dan 3 dengan 1 ; 1, 2 dan 1, 2, 3 (resp.), Menghasilkan [1, 1, 2, 1, 2, 3] .

Akhirnya, kami melakukan penggantian yang sama seperti pada langkah sebelumnya untuk semua enam bilangan bulat dalam array, menghasilkan [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Ini adalah array CURR ketiga.

Tugas

Tulis program fungsi yang, diberi bilangan bulat positif n sebagai input, menghitung array CURR ^ke- n .

Outputnya harus berupa daftar datar (dan array dikembalikan dari suatu fungsi, representasi string dari sintaks array bahasa Anda, dipisahkan dengan spasi putih, dll.).

Ini adalah kode-golf . Semoga kode terpendek dalam byte menang!

Uji kasus

 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]

Jelly, 3 byte

R¡F

Cobalah online

Penjelasan

R¡F    Argument n

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

Python, 50 byte

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

Penyalahgunaan ruang lingkup! Misalnya, untuk i=3, string yang akan dievaluasi meluas ke.

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

Entah bagaimana, meskipun menggunakan variabel input fungsi iuntuk semuanya, Python membedakan setiap indeks iterasi sebagai milik lingkup yang terpisah seolah-olah ekspresi

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

dengan iinput ke fungsi.

05AB1E, 6 3 byte

DFL

Dijelaskan

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

Cobalah online

Disimpan 3 byte berkat @Adnan

Retina , 33 byte

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

Input dan output di unary.

Cobalah online!

Meskipun saya tidak menggunakan formulir tertutup untuk tantangan terkait, mengadaptasi jawaban ini ternyata sangat sulit.

Python 2, 82 byte

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

Ini bukan solusi terpendek, tetapi menggambarkan metode yang menarik:

• Tuliskan dulu 2^(2*n-1) angka dalam biner
• Simpan dengan tepat n yang
• Untuk setiap angka, hitung jumlah nol yang tertinggal, dan tambahkan 1.

Sebenarnya, 9 byte

;#@`♂RΣ`n

Cobalah online!

Penjelasan:

;#@`♂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

Terima kasih kepada Leaky Nun untuk satu byte, dan inspirasi untuk 2 byte lainnya.

C #, 128 Bytes

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 byte

{∊⍳¨∘∊⍣⍵+⍵}

Uji:

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

Penjelasan:

• +⍵: dimulai dengan ⍵,
• ⍣⍵: lakukan waktu berikut ⍵:
  • ⍳¨∘∊: ratakan input, dan kemudian buat daftar [1..N] untuk setiap N dalam input
• ∊: meratakan hasil itu

CJam, 14 byte

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

Uji di sini.

Penjelasan

_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 byte

1 byte disimpan dengan beberapa inspirasi dari jawaban Essari.

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

Cukup mudah: untuk input xkita mulai dengan {x}dan kemudian menerapkan Rangeuntuk itu xkali ( Rangeadalah Listableyang berarti bahwa secara otomatis berlaku untuk bilangan bulat dalam daftar sewenang-wenang bersarang). Pada akhirnya Flattenhasilnya.

Clojure, 59 byte

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

Penjelasan:

Cara yang benar-benar lurus ke depan untuk menyelesaikan masalah. Bekerja dari dalam ke luar:

(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 byte

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

Ini hanya terjemahan langsung dari deskripsi masalah ke kode.

Sunting: Disimpan satu byte berkat @Dennis.

R, 60 49 byte

Cukup mudah digunakan unlistdan sapply.

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

Terima kasih kepada @MickyT karena telah menghemat 11 byte

php 121

Tidak terlalu banyak trik di belakang yang satu ini. Meratakan sebuah array dalam php tidak pendek sehingga perlu untuk membuatnya datar di tempat pertama

<?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 byte

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

Terima kasih kepada nimi karena telah menghemat satu byte.

Versi pointfree lebih panjang (35 byte):

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

JavaScript (Firefox 30-57), 63 60 byte

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

Port of @xnor's Python answer.

J, 18 bytes

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

Straight-forward approach based on the process described in the challenge.

Usage

   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

Explanation

([:;<@(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 bytes

usSMGQ]Q

Try it 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.

Jelly, 7 bytes

Quick, before Dennis answers (jk)

WR€F$³¡

Try it 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 bytes

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

Returns an anonymous function taking n as input.

Replaces every entry k in A with [1..k], repeats the process n times, starting with A = [n].

Swift 3, 58 Bytes

Meant to run directly in the a playground, with n set to the input:

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

Ungolfed, with most short hand notation reverted:

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 Bytes

Procedure

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

Usage

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

Sample output:

[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 bytes

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

Edit: Saved 1 byte thanks to @xnor. Saved 2 bytes thanks to @Dennis♦.

Bash + GNU utilities, 49

• 1 byte saved thanks to @Dennis.

Piped recursive functions FTW!

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

n is passed on the command-line. Output is newline-separated.

The use of dd causes statistics to be sent to STDERR. I think this is OK, but if not, dd can be replaced with cat at a cost of 1 extra byte.

Perl 5, 53 bytes

A subroutine:

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

See it in action as

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

Ruby, 61 bytes

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

PHP, 100 98 bytes

Run with 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);

In each iteration create a temporary copy looping from 1..(first value removed) until $a is empty.

These two are still and will probably remain at 100 bytes:

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

In each iteration loop backwards through array replacing each number with a range.

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

In each iteration loop through array increasing index by previous number and replacing each indexed element with a range