Định nghĩa

Xác định mảng ^thứ n của chuỗi CURR như sau.

1. Bắt đầu với mảng singleton A = [n] .

2. Với mỗi số nguyên k trong A , thay thế mục k bằng số tự nhiên k , đếm từ 1 đến k .

3. Lặp lại bước trước n - 1 lần nữa.

Ví dụ: nếu n = 3 , chúng ta bắt đầu với mảng [3] .

Chúng tôi thay 3 bằng 1, 2, 3 , cho năng suất [1, 2, 3] .

Bây giờ chúng ta thay thế 1 , 2 và 3 bằng 1 ; 1, 2 và 1, 2, 3 (tương ứng), mang lại [1, 1, 2, 1, 2, 3] .

Cuối cùng, chúng tôi thực hiện các thay thế tương tự như trong bước trước cho tất cả sáu số nguyên trong mảng, mang lại [1, 1, 1, 2, 1, 1, 2, 1, 2, 3] . Đây là mảng CURR thứ ba.

Bài tập

Viết chương trình của hàm, với số nguyên n dương hoàn toàn làm đầu vào, tính toán mảng CURR ^thứ n .

Đầu ra phải là một danh sách phẳng của một số loại (và mảng được trả về từ một hàm, biểu diễn chuỗi của cú pháp mảng ngôn ngữ của bạn, được phân tách bằng khoảng trắng, v.v.).

Đây là mã golf . Có thể mã ngắn nhất trong byte giành chiến thắng!

Các trường hợp thử nghiệm

 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]

Thạch, 3 byte

R¡F

Dùng thử trực tuyến

Giải trình

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+"]")

Lạm dụng phạm vi! Ví dụ, đối với i=3, chuỗi được đánh giá mở rộng thành.

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

Bằng cách nào đó, mặc dù sử dụng biến đầu vào hàm icho mọi thứ, Python phân biệt từng chỉ số lặp là thuộc một phạm vi riêng như thể biểu thức là

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

với iđầu vào cho hàm.

05AB1E, 6 3 byte

DFL

Giải thích

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

Dùng thử trực tuyến

Đã lưu 3 byte nhờ @Adnan

Võng mạc , 33 byte

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

Đầu vào và đầu ra trong unary.

Hãy thử trực tuyến!

Mặc dù tôi đã không sử dụng hình thức đóng cho thử thách liên quan, nhưng việc điều chỉnh câu trả lời này thật khó khăn.

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]

Đây không phải là giải pháp ngắn nhất, nhưng nó minh họa một phương pháp thú vị:

• Viết các 2^(2*n-1)số đầu tiên vào nhị phân
• Giữ những người có chính xác nnhững
• Đối với mỗi số, hãy đếm số lượng các số 0 ở cuối và thêm 1.

Trên thực tế, 9 byte

;#@`♂RΣ`n

Hãy thử trực tuyến!

Giải trình:

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

Cảm ơn Leaky Nun cho một byte và cảm hứng cho 2 byte khác.

C #, 128 byte

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

{∊⍳¨∘∊⍣⍵+⍵}

Kiểm tra:

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

Giải trình:

• +⍵: bắt đầu bằng ⍵,
• ⍣⍵: làm những ⍵lần sau :
  • ⍳¨∘∊: làm phẳng đầu vào, rồi tạo danh sách [1..N] cho mỗi N trong đầu vào
• ∊: làm phẳng kết quả của điều đó

CJam, 14 byte

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

Kiểm tra nó ở đây.

Giải trình

_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.
}*

Toán học, 27 26 byte

1 byte được lưu với một số cảm hứng từ câu trả lời của Essari.

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

Khá đơn giản: cho đầu vào xchúng ta bắt đầu với {x}và sau đó áp dụng Rangenó xlần ( Rangelà Listablecó nghĩa là nó sẽ tự động áp dụng cho các số nguyên trong danh sách tùy tiện lồng nhau). Cuối cùng Flattenkết quả.

Clojure, 59 byte

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

Giải trình:

Thực sự thẳng về phía trước để giải quyết vấn đề. Làm việc từ trong ra ngoài:

(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)')

Đây chỉ là một bản dịch đơn giản của mô tả vấn đề sang mã.

Chỉnh sửa: Đã lưu một byte nhờ @Dennis.

R, 60 49 byte

Khá đơn giản sử dụng unlistvà sapply.

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

Cảm ơn @MickyT vì đã lưu 11 byte

php 121

Không thực sự rất nhiều trong cách thủ đoạn đằng sau này. Làm phẳng một mảng trong php không phải là ngắn nên cần phải xây dựng nó phẳng ngay từ đầu

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

Cảm ơn nimi vì đã tiết kiệm một byte.

Phiên bản pointfree dài hơn (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]`)

Cổng câu trả lời Python của @ xnor.

J, 18 byte

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

Phương pháp tiếp cận thẳng dựa trên quá trình được mô tả trong thử thách.

Sử dụng

   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

Giải trình

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

Bình thường, 8 byte

usSMGQ]Q

Hãy thử trực tuyến!

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.

Thạch, 7 byte

Nhanh lên, trước khi Dennis trả lời (jk)

WR€F$³¡

Hãy thử trực tuyến!

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 byte

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

Trả về một hàm ẩn danh lấy n làm đầu vào.

Thay thế mọi mục nhập k trong A bằng [1..k], lặp lại quá trình n lần, bắt đầu bằng A = [n].

Swift 3, 58 byte

Có nghĩa là chạy trực tiếp trong sân chơi, với n được đặt thành đầu vào:

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

Ungolfed, với hầu hết các ký hiệu tay ngắn được hoàn nguyên:

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 byte

Thủ tục

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

Sử dụng

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

Đầu ra mẫu:

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

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

Chỉnh sửa: Đã lưu 1 byte nhờ @xnor. Đã lưu 2 byte nhờ @ Dennis ♦.

Tiện ích Bash + GNU, 49

• Lưu 1 byte nhờ @Dennis.

Chức năng đệ quy đường ống FTW!

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

nđược truyền vào dòng lệnh. Đầu ra được phân tách dòng mới.

Việc sử dụng số ddliệu thống kê nguyên nhân được gửi đến STDERR. Tôi nghĩ rằng điều này là ổn, nhưng nếu không, ddcó thể được thay thế với catchi phí thêm 1 byte.

Perl 5, 53 byte

Một chương trình con:

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

Xem nó trong hành động như

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

Ruby, 61 byte

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

PHP, 100 98 byte

Chạy với 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);

Trong mỗi lần lặp, tạo một vòng lặp sao chép tạm thời từ 1 .. (giá trị đầu tiên bị xóa) cho đến khi $atrống.

Hai cái này vẫn và có thể sẽ vẫn ở mức 100 byte:

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

Trong mỗi vòng lặp lặp lại thông qua mảng thay thế mỗi số bằng một phạm vi.

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

Trong mỗi vòng lặp thông qua chỉ số tăng mảng theo số trước đó và thay thế từng phần tử được lập chỉ mục bằng một phạm vi