Thử thách này chỉ đơn giản là trả về một danh sách các danh sách các số nguyên, tương tự như hàm phạm vi Python, ngoại trừ mỗi số liên tiếp phải nằm sâu trong danh sách.

Quy tắc :

• Tạo một chương trình hoặc một chức năng không ẩn danh
• Nó sẽ trả lại hoặc in kết quả
• Kết quả phải được trả về trong một danh sách (danh sách) hoặc mảng (của mảng)
• Nếu tham số bằng 0, trả về một danh sách trống
• Điều này sẽ có thể xử lý một tham số nguyên 0 <= n <70.
  • (giải pháp đệ quy thổi lên khá nhanh)
• Hàm nên có thể gọi được với chỉ một tham số.
• Hành vi khác là không xác định.
• Đây là mã golf, vì vậy mã ngắn nhất sẽ thắng.

Cuộc gọi ví dụ:

rangeList(6)
> [0, [1, [2, [3, [4, [5]]]]]]

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

0  => []
1  => [0]
2  => [0, [1]]
6  => [0, [1, [2, [3, [4, [5]]]]]]
26 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25]]]]]]]]]]]]]]]]]]]]]]]]]]
69 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

EDIT: câu trả lời của isaacg là ngắn nhất cho đến nay. Tôi sẽ cập nhật câu trả lời được chấp nhận nếu có ai tìm thấy câu trả lời ngắn hơn bằng ngôn ngữ tồn tại khi đăng bài thách thức. Cảm ơn đã chơi cùng!

Bình thường, 13 byte

?hu]+HG_UQYQY

Hãy thử nó ở đây.

                 Implicit:
                 Q = eval(input())
                 Y = []
?           QY   If Q = 0, print Y
 h               else, print the first element of
  u     _UQY     the reduce, where Y is the initial value, over the list
                 reversed(range(Q))
   ]+HG          The reduce function: The list containing H prepended onto G.
                 The new number is inserted into the accumulated list,
                 then the resultant list is wrapped in another list.

APL ( 13 18)

Giả sử ⎕IO=0:

f←{×⍵:⊃,∘⊂∘,/⍳⍵⋄⍬}

Giải trình:

• ×⍵:nếu ⍵là tích cực,
  • ,∘⊂∘,: tham gia toán hạng bên trái để bao quanh toán hạng bên phải (nghĩa là x ,∘⊂∘, y = [x, [y]])
  • /: giảm
  • ⍳⍵: những con số 0..⍵-1
  • ⊃: tiết lộ kết quả
• ⋄: nếu không thì
  • ⍬: trả về danh sách trống
  • (điều này là cần thiết vì /không thành công ⍬và ⍳0đưa ra danh sách trống.)

Phụ lục:

Hàm này trả về một mảng lồng nhau. Tuy nhiên, hơi khó để nói điều này từ đầu ra mặc định của APL. Nó phân tách các mục mảng bằng khoảng trắng, vì vậy bạn chỉ có thể nói lồng nhau bằng dấu cách kép. Đây là một hàm sẽ lấy một mảng lồng nhau và trả về một chuỗi, định dạng mảng được lồng theo kiểu Python (tức là [a,[b,[c,...]]]).

arrfmt←{0=≡⍵:⍕⍵ ⋄ '[',(1↓∊',',¨∇¨⍵),']'}

Haskell, 67 byte

data L=E|I Int|L[L] 
1#m=L[I$m-1]
n#m=L[I$m-n,(n-1)#m]
p 0=E
p n=n#n

Trong Haskell, tất cả các thành phần của danh sách phải cùng loại, vì vậy tôi không thể trộn số nguyên với danh sách số nguyên và tôi phải xác định loại danh sách tùy chỉnh L. Hàm trợ giúp #xây dựng đệ quy danh sách cần thiết. Hàm chính pkiểm tra danh sách trống và gọi #khác.

Vì các loại dữ liệu mới không thể được in theo mặc định (các quy tắc cho phép chỉ trả về danh sách), tôi thêm một số mã cho mục đích trình diễn:

data L=E|I Int|L[L] deriving Show

Hiện nay:

-- mapM_ (print . p) [0..5]
E
L [I 0]
L [I 0,L [I 1]]
L [I 0,L [I 1,L [I 2]]]
L [I 0,L [I 1,L [I 2,L [I 3]]]]
L [I 0,L [I 1,L [I 2,L [I 3,L [I 4]]]]]

Python, 48 byte

f=lambda n,i=0:i<n and[i]+[f(n,i+1)]*(i<n-1)or[]

Sử dụng danh sách nhân để xử lý trường hợp đặc biệt.

Toán học, 33

f@0={};f@1={0};f@n_:={0,f[n-1]+1}

CJam, 16 byte

Lri){[}%]~;']*~p

Đây là một chương trình đầy đủ. Nó nhận đầu vào thông qua STDIN và in mảng cuối cùng vào STDOUT.

Cũng như mục nhập khác của CJam, 0đầu vào sẽ in ""vì đó là đại diện của một mảng trống trong CJam.

Cách thức hoạt động :

L                   "Put an empty array on stack. This will be used for the 0 input";
 ri)                "Read the input, convert it to integer and increment it";
    {[}%            "Map over the array [0 ... input number] starting another array";
                    "after each element";
        ]~;         "Now on stack, we have input number, an empty array and the final";
                    "opening bracket. Close that array, unwrap it and pop the empty array";
           ']*~     "Put a string containing input number of ] characters and eval it";
                    "This closes all the opened arrays in the map earlier";
               p    "Print the string representation of the array";
                    "If the input was 0, the map runs 1 time and the ; pops that 1 array";
                    "Thus leaving only the initial empty array on stack";

Dùng thử trực tuyến tại đây

JavaScript (ES6) 40

Giải pháp đệ quy, khá mạnh mẽ, không có đòn. Cập nhật thất bại gần 6500 với 'quá nhiều đệ quy'

F=n=>n--?(R=m=>m<n?[m,R(++m)]:[m])(0):[]

Giải pháp lặp (45) Không giới hạn ngoại trừ sử dụng bộ nhớ

F=n=>{for(s=n?[--n]:[];n;)s=[--n,s];return s}

Hãy thử F (1000): Bảng điều khiển FireBug sẽ không hiển thị cho bạn hơn 190 mảng lồng nhau, nhưng chúng ở đó

Java, 88 107 105 104 102 byte

import java.util.*;int o;List f(final int n){return new Stack(){{add(n<1?"":o++);if(o<n)add(f(n));}};}

Khá lâu so với những người khác, mặc dù bạn không thể làm tốt hơn với Java. Một kiểm tra để xác định xem có nên tiếp tục đệ quy hay không.

Python 2, 56 byte

Tôi nghi ngờ điều này có thể được chơi golf nhiều hơn.

f=lambda n,i=0:[i,f(n,i+1)]if i<n-1 else[i]if n>0 else[]

Các xét nghiệm:

# for n in (0,1,2,6,26,69): print n, '=>', f(n)
0 => []
1 => [0]
2 => [0, [1]]
6 => [0, [1, [2, [3, [4, [5]]]]]]
26 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25]]]]]]]]]]]]]]]]]]]]]]]]]]
69 => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

CJam, 17 byte

Tôi biết Trình tối ưu hóa đã tìm thấy 16, nhưng đây là cách tốt nhất tôi có thể làm:

{:I{[}%;{]}I1e>*}

Đây là một khối, thứ gần nhất với một hàm trong CJam, lấy một số nguyên trên ngăn xếp và để lại mảng lồng mong muốn.

Sử dụng chương trình này để kiểm tra nó , đưa đầu vào vào ngăn xếp, sau đó gọi hàm và kiểm tra ngăn xếp. Lưu ý rằng 0, đầu ra ngăn xếp sẽ chứa ""- đây là biểu diễn gốc của CJam của một mảng trống.

Hồng ngọc 46

f=->n{r=a=[]
(0...n).map{|i|a<<a=[i]}
r[0]||r}

Kiểm tra trực tuyến: http://ideone.com/uYRVTa

C # - 100

Đệ quy đơn giản. Kiểm tra trường hợp đặc biệt bằng 0 và đánh dấu lên với một biến, xuống với biến khác

object[]A(int y,int x=0){return y==0?new object[0]:y==1?new object[]{x}:new object[]{x,A(--y,++x)};}

C ++ 87

(Trực quan C ++ 2012)

int*A(int y,int x=0){int*b=new int{x};return!y?new int:--y?(b[1]=(int)A(y,++x))?b:0:b;}

Điều này thật tuyệt, ý tôi là byzantine, nhưng đó là ý tưởng cơ bản giống như c # one.

Đó là một triển khai mảng kiểu C, vì vậy nó không cung cấp cho bạn một mảng, nó cung cấp một con trỏ int, trong đó tôi đang lưu trữ cả ints và các con trỏ khác. Giống như thế này : [0,*] *->[1,#] #-> [2,&] &-> etc, trong đó các ký hiệu là mã giả cho giá trị int của một con trỏ và -> là nơi nó trỏ đến trong bộ nhớ.

Thật là một cách dễ dàng để sử dụng các mảng lởm chởm kiểu c mà tôi đã nghĩ ra (ho), nhưng tôi duy trì nó đủ hợp lý để nằm trong các quy tắc của câu hỏi.

Có khá nhiều người lạm dụng các nhà khai thác ternary ở đây, và cũng có khá nhiều việc lạm dụng các diễn viên ngầm từ int đến bool.

Ví dụ: Nếu chúng ta cho phép int *bar = (int*)A(3);, chúng ta có thể thấy:

bar
0x003bded8 {0}
((int*)bar[1])[0]
1
((int*)(((int*)bar[1])[1]))[0]
2

Đó là nói chuyện con trỏ cho [0, [1, [2]]].

Tốt. Nó không thực sự phải là khủng khiếp. Đây là một số mã kiểm tra để chạy mã c ++ này:

int* GetNext(int* p){
  return (int*)p[1];
}

int main()
{
    auto x = 10;
    auto bar = A(x);

    for (int i = 1; i < x; i++){
        bar = GetNext(bar);
        std::cout << bar[0] << std::endl;
    }

}

Bình thường, 15 byte

?u[HG)_UtQ]tQQY

Điều thực sự đang nói, trong Python:

Q = eval(input())
if Q:
    print reduce(lambda G,H:[H,G], reverse(range(Q-1)), [Q-1])
else:
    print []

Haskell , 65 59 45 41 byte

Các danh sách lồng nhau này có cùng cấu trúc dữ liệu với Trees gốc , ngoại trừ việc chúng cũng có thể trống. Do đó, chúng ta có thể sử dụng một danh sách của họ - còn được gọi là Forestđại diện cho họ.

(0!)
data T=N[T]Int
m!n=[N((m+1)!n)m|m<n]

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

Giải trình

Trước hết chúng ta cần thực hiện Treekiểu dữ liệu:

data Tree = Node [Tree] Int

Từ đó, chỉ cần đệ quy bằng hai tham số m(đếm ngược) và nđể theo dõi khi nào chấm dứt:

m ! n= [ Node ((m+1)!n) m| m<n ]

Thay thế, 61 byte

import Data.Tree
f n=unfoldForest(\b->(b,[b+1|b<n-1]))[0|n>0]

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

Giải trình

Hàm unfoldForestlấy danh sách các giá trị ban đầu và hàm x -> (y,[x]). Đối với mỗi giá trị ban đầu, xnó mở ra một cây bằng cách sử dụng hàm, tạo ra một tuple (y,xs)nơi ysẽ trở thành gốc và xsđược sử dụng để lặp lại thủ tục:

unfoldForest (\b -> (b, [b+1 | b < 2]) [0]
  ≡ Node 0 [unfoldForest (\b -> (b, [b+1 | b < 2) [1]]
  ≡ Node 0 [Node 1 [unfoldForest (\b -> (b, [b+1 | b < 2) []]]
  ≡ Node 0 [Node 1 []]

Perl - 44

sub t{$r=[($t)=@_];$r=[$t,$r]while--$t>0;$r}

Sẽ thêm lời giải thích theo yêu cầu. Bạn có thể thử nó ở đây .

JavaScript, 93 byte

Điều này không lý tưởng, nhưng tôi cũng có thể thử. Tôi sẽ thử và chơi golf này sau này, mặc dù bây giờ tôi không thấy cách nào rõ ràng.

function f(n){s='[';i=0;while(i<n-1)s+=i+++',[';s+=i||'';do{s+=']'}while(i--);return eval(s)}

Python, 75 byte

Đây chỉ là chương trình. Đó là chương trình tôi đã viết khi tạo / thiết kế thử thách này.

f=lambda x,y=[]:y if x<1 else f(x-1,[x-2]+[y or[x-1]])if x>1 else y or[x-1]

Con trăn, 44

f=lambda n,i=0:i<n-1and[i,f(n,i+1)]or[i][:n]

Đệ quy tạo cây. Các [:n]cuối cùng là đặc biệt hợp cụ thể n==0vào đưa ra danh sách trống.

Joe , 8 byte

Lưu ý: Đây là một câu trả lời không cạnh tranh. Phiên bản đầu tiên của Joe đã được phát hành sau câu hỏi này.

F:/+,M]R

Chúng ta có gì ở đây? F:định nghĩa một hàm F đó là một chuỗi /+,, M]và R. Khi bạn gọi Fn, đầu tiên Rnđược đánh giá, trả về phạm vi từ 0 đến n, độc quyền. M]kết thúc mỗi phần tử vào một danh sách. Sau đó, danh sách được áp dụng cho /+,. x +, y trả lại x + [y]. /là một nếp gấp đúng Như vậy, /+,a b c d...trả lại [a, [b, [c, [d...]]].

Các ví dụ (mã được thụt vào 3, đầu ra bằng 0):

   F:/+,M]R
   F10
[0, [1, [2, [3, [4, [5, [6, [7, [8, [9]]]]]]]]]]
   F2
[0, [1]]
   F1
[0]
   F0
[]
   F_5
[0, [-1, [-2, [-3, [-4]]]]]

Ruby - Phiên bản đệ quy - 52

r=->(n,v=nil){(n-=1;n<0 ?v:r[n,(v ?[n,v]:[n])])||[]}

Phiên bản không đệ quy: 66 62 57

r=->i{(i-1).downto(0).inject(nil){|a,n|a ?[n,a]:[n]}||[]}

Đầu ra mẫu (giống nhau cho cả hai phiên bản)

p r[0]  # => []
p r[1]  # => [0]
p r[2]  # => [0, [1]]
p r[6]  # => [0, [1, [2, [3, [4, [5]]]]]]
p r[26] # => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25]]]]]]]]]]]]]]]]]]]]]]]]]]
p r[69] # => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Phiên bản không đệ quy có thể xử lý đầu vào lớn tùy ý.

p r[1000] # => [0, [1, [2, [3, [4, [5, [6, [7, [8, [9, [10, [11, [12, [13, [14, [15, [16, [17, [18, [19, [20, [21, [22, [23, [24, [25, [26, [27, [28, [29, [30, [31, [32, [33, [34, [35, [36, [37, [38, [39, [40, [41, [42, [43, [44, [45, [46, [47, [48, [49, [50, [51, [52, [53, [54, [55, [56, [57, [58, [59, [60, [61, [62, [63, [64, [65, [66, [67, [68, [69, [70, [71, [72, [73, [74, [75, [76, [77, [78, [79, [80, [81, [82, [83, [84, [85, [86, [87, [88, [89, [90, [91, [92, [93, [94, [95, [96, [97, [98, [99, [100, [101, [102, [103, [104, [105, [106, [107, [108, [109, [110, [111, [112, [113, [114, [115, [116, [117, [118, [119, [120, [121, [122, [123, [124, [125, [126, [127, [128, [129, [130, [131, [132, [133, [134, [135, [136, [137, [138, [139, [140, [141, [142, [143, [144, [145, [146, [147, [148, [149, [150, [151, [152, [153, [154, [155, [156, [157, [158, [159, [160, [161, [162, [163, [164, [165, [166, [167, [168, [169, [170, [171, [172, [173, [174, [175, [176, [177, [178, [179, [180, [181, [182, [183, [184, [185, [186, [187, [188, [189, [190, [191, [192, [193, [194, [195, [196, [197, [198, [199, [200, [201, [202, [203, [204, [205, [206, [207, [208, [209, [210, [211, [212, [213, [214, [215, [216, [217, [218, [219, [220, [221, [222, [223, [224, [225, [226, [227, [228, [229, [230, [231, [232, [233, [234, [235, [236, [237, [238, [239, [240, [241, [242, [243, [244, [245, [246, [247, [248, [249, [250, [251, [252, [253, [254, [255, [256, [257, [258, [259, [260, [261, [262, [263, [264, [265, [266, [267, [268, [269, [270, [271, [272, [273, [274, [275, [276, [277, [278, [279, [280, [281, [282, [283, [284, [285, [286, [287, [288, [289, [290, [291, [292, [293, [294, [295, [296, [297, [298, [299, [300, [301, [302, [303, [304, [305, [306, [307, [308, [309, [310, [311, [312, [313, [314, [315, [316, [317, [318, [319, [320, [321, [322, [323, [324, [325, [326, [327, [328, [329, [330, [331, [332, [333, [334, [335, [336, [337, [338, [339, [340, [341, [342, [343, [344, [345, [346, [347, [348, [349, [350, [351, [352, [353, [354, [355, [356, [357, [358, [359, [360, [361, [362, [363, [364, [365, [366, [367, [368, [369, [370, [371, [372, [373, [374, [375, [376, [377, [378, [379, [380, [381, [382, [383, [384, [385, [386, [387, [388, [389, [390, [391, [392, [393, [394, [395, [396, [397, [398, [399, [400, [401, [402, [403, [404, [405, [406, [407, [408, [409, [410, [411, [412, [413, [414, [415, [416, [417, [418, [419, [420, [421, [422, [423, [424, [425, [426, [427, [428, [429, [430, [431, [432, [433, [434, [435, [436, [437, [438, [439, [440, [441, [442, [443, [444, [445, [446, [447, [448, [449, [450, [451, [452, [453, [454, [455, [456, [457, [458, [459, [460, [461, [462, [463, [464, [465, [466, [467, [468, [469, [470, [471, [472, [473, [474, [475, [476, [477, [478, [479, [480, [481, [482, [483, [484, [485, [486, [487, [488, [489, [490, [491, [492, [493, [494, [495, [496, [497, [498, [499, [500, [501, [502, [503, [504, [505, [506, [507, [508, [509, [510, [511, [512, [513, [514, [515, [516, [517, [518, [519, [520, [521, [522, [523, [524, [525, [526, [527, [528, [529, [530, [531, [532, [533, [534, [535, [536, [537, [538, [539, [540, [541, [542, [543, [544, [545, [546, [547, [548, [549, [550, [551, [552, [553, [554, [555, [556, [557, [558, [559, [560, [561, [562, [563, [564, [565, [566, [567, [568, [569, [570, [571, [572, [573, [574, [575, [576, [577, [578, [579, [580, [581, [582, [583, [584, [585, [586, [587, [588, [589, [590, [591, [592, [593, [594, [595, [596, [597, [598, [599, [600, [601, [602, [603, [604, [605, [606, [607, [608, [609, [610, [611, [612, [613, [614, [615, [616, [617, [618, [619, [620, [621, [622, [623, [624, [625, [626, [627, [628, [629, [630, [631, [632, [633, [634, [635, [636, [637, [638, [639, [640, [641, [642, [643, [644, [645, [646, [647, [648, [649, [650, [651, [652, [653, [654, [655, [656, [657, [658, [659, [660, [661, [662, [663, [664, [665, [666, [667, [668, [669, [670, [671, [672, [673, [674, [675, [676, [677, [678, [679, [680, [681, [682, [683, [684, [685, [686, [687, [688, [689, [690, [691, [692, [693, [694, [695, [696, [697, [698, [699, [700, [701, [702, [703, [704, [705, [706, [707, [708, [709, [710, [711, [712, [713, [714, [715, [716, [717, [718, [719, [720, [721, [722, [723, [724, [725, [726, [727, [728, [729, [730, [731, [732, [733, [734, [735, [736, [737, [738, [739, [740, [741, [742, [743, [744, [745, [746, [747, [748, [749, [750, [751, [752, [753, [754, [755, [756, [757, [758, [759, [760, [761, [762, [763, [764, [765, [766, [767, [768, [769, [770, [771, [772, [773, [774, [775, [776, [777, [778, [779, [780, [781, [782, [783, [784, [785, [786, [787, [788, [789, [790, [791, [792, [793, [794, [795, [796, [797, [798, [799, [800, [801, [802, [803, [804, [805, [806, [807, [808, [809, [810, [811, [812, [813, [814, [815, [816, [817, [818, [819, [820, [821, [822, [823, [824, [825, [826, [827, [828, [829, [830, [831, [832, [833, [834, [835, [836, [837, [838, [839, [840, [841, [842, [843, [844, [845, [846, [847, [848, [849, [850, [851, [852, [853, [854, [855, [856, [857, [858, [859, [860, [861, [862, [863, [864, [865, [866, [867, [868, [869, [870, [871, [872, [873, [874, [875, [876, [877, [878, [879, [880, [881, [882, [883, [884, [885, [886, [887, [888, [889, [890, [891, [892, [893, [894, [895, [896, [897, [898, [899, [900, [901, [902, [903, [904, [905, [906, [907, [908, [909, [910, [911, [912, [913, [914, [915, [916, [917, [918, [919, [920, [921, [922, [923, [924, [925, [926, [927, [928, [929, [930, [931, [932, [933, [934, [935, [936, [937, [938, [939, [940, [941, [942, [943, [944, [945, [946, [947, [948, [949, [950, [951, [952, [953, [954, [955, [956, [957, [958, [959, [960, [961, [962, [963, [964, [965, [966, [967, [968, [969, [970, [971, [972, [973, [974, [975, [976, [977, [978, [979, [980, [981, [982, [983, [984, [985, [986, [987, [988, [989, [990, [991, [992, [993, [994, [995, [996, [997, [998, [999]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Cả hai phiên bản cũng duyên dáng chấp nhận số âm

p r[-5] # => []

PHP 5.4 (67 byte):

Tôi biết rồi mà.

Đó là xa câu trả lời ngắn nhất.

Nhưng nó đã có tác dụng!

Đây là:

function F($n){for($c=$n?[--$n]:[];~$n&&$n--;$c=[$n,$c]);return$c;}

Bạn có thể kiểm tra nó ngay tại đây: https://ideone.com/42L35E (bỏ qua lỗi)

Javascript (57 byte):

Đây là cùng một mã chính xác ngoại trừ Javascript rất kén chọn về lợi nhuận và tôi đã giảm các tên biến:

function F(n){for(c=n?[--n]:[];~n&&n--;c=[n,c]);return c}

Xem? Cùng mã!

ES6 (49 byte):

Về cơ bản cùng một mã chính xác, nhưng giảm cho ES6:

F=n=>{for(c=n?[--n]:[];~n&&n--;c=[n,c]);return c}

Javascript (114 byte):

Mọi người khác đang thực hiện đệ quy, vì vậy tôi muốn thử một giải pháp lặp lại. Tôi có quá nhiều trường hợp đặc biệt, mặc dù.

Tôi giữ một danh sách chính, sau đó lặp và nối các danh sách mới với các số mới.

function q(n){a=[];if(n==1)a=[0];else if(n!=0){a=[0,b=[]];for(i=1;i<n;){c=[];b.push(c);b.push(i++);b=c}}return a}

Lisp thường gặp (95 byte):

(defun f(n &optional(i 0))(cond((< i(1- n))(cons i(list(f n(1+ i)))))((> n 0)(list i))(t nil)))

JavaScript, 35 37 byte

Giải pháp đệ quy

f=(n,x=[])=>n?f(--n,x[0]?[n,x]:[n]):x

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

05AB1E , 11 byte

_i¯ëFNI<α)R

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Thay thế 11 byte:

_i¯ëݨRvy)R

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

05AB1E không có vòng lặp đi xuống, vì vậy để lặp trong phạm vi (input, 0]tôi phải:

• Tạo phạm vi đó trước ( ݨR; tạo phạm vi [0, input], xóa mục cuối cùng, đảo ngược) và sau đó lặp qua phạm vi đó ( vy);
• Hoặc lặp trong phạm vi [0, input)thay thế ( F) và lấy sự khác biệt tuyệt đối giữa chỉ số vòng lặp và đầu vào-1 ( NI<α).

_i          # If the (implicit) input is 0:
  ¯         #  Push the global array (empty by default)
 ë          # Else:
  F         #  Loop `N` in the range [0, (implicit) input):
   N        #   Push index `N`
    I<      #   Push input-1
      α     #   Take the absolute difference between the two
       )    #   Wrap everything on the stack into a list
        R   #   Reverse the list
            # (output the result implicitly after the if/loop)