Эта задача состоит в том, чтобы просто вернуть список списков целых чисел, аналогично функции диапазона Python, за исключением того, что каждое последующее число должно быть так глубоко в списках.

Правила :

• Создать программу или неанонимную функцию
• Должен вернуть или распечатать результат
• Результат должен быть возвращен в виде списка (списков) или массива (массивов)
• Если параметр равен нулю, вернуть пустой список
• Это должно быть в состоянии обработать целочисленный параметр 0 <= n <70.
  • (рекурсивные решения взрываются довольно быстро)
• Функция должна вызываться только с одним параметром.
• Другое поведение не определено.
• Это код гольф, поэтому выигрывает самый короткий код.

Пример вызова:

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

Тестовые случаи:

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

РЕДАКТИРОВАТЬ: ответ Исаака является самым коротким до сих пор. Я обновлю принятый ответ, если кто-нибудь найдет более короткий ответ на языке, существовавшем на момент подачи заявки. Спасибо за игру!

Pyth, 13 байт

?hu]+HG_UQYQY

Попробуй это здесь.

                 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)

Предполагая ⎕IO=0:

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

Объяснение:

• ×⍵:если ⍵положительно,
  • ,∘⊂∘,: присоединить левый операнд к вложению правого операнда (то есть x ,∘⊂∘, y = [x, [y]])
  • /: уменьшить
  • ⍳⍵: числа 0..⍵-1
  • ⊃: раскрыть результат
• ⋄: иначе
  • ⍬: вернуть пустой список
  • (это необходимо, потому что происходит /сбой ⍬и ⍳0дает пустой список.)

Приложение:

Эта функция возвращает вложенный массив. Тем не менее, это немного трудно сказать по выводу APL по умолчанию. Он разделяет элементы массива по пробелам, поэтому вы можете сказать, что вложенность только по двойным пробелам. Вот функция, которая будет принимать вложенный массив и возвращать строку, форматируя вложенный массив в стиле Python (т.е. [a,[b,[c,...]]]).

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

Haskell, 67 байт

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

В Haskell все элементы списка должны быть одного типа, поэтому я не могу смешивать целые числа со списком целых чисел, и мне нужно определить пользовательский тип списка L. Вспомогательная функция #рекурсивно создает необходимый список. Основная функция pпроверяет пустой список и вызывает в #противном случае.

Поскольку новые типы данных не могут быть напечатаны по умолчанию (правила позволяют просто вернуть список), я добавлю еще немного кода для демонстрации:

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

В настоящее время:

-- 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 байт

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

Использование умножения списка для обработки особого случая.

Математика, 33

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

CJam, 16 байтов

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

Это полная программа. Он принимает ввод через STDIN и печатает окончательный массив в STDOUT.

Как и с другой записью CJam, 0input будет печататься, ""поскольку это представление пустого массива в CJam.

Как это работает :

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

Попробуйте это онлайн здесь

JavaScript (ES6) 40

Рекурсивное решение, довольно надежное, без ударов. Сбой обновления около 6500 с «слишком большой рекурсией»

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

Итеративное решение (45) Нет ограничений, кроме использования памяти

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

Попробуйте F (1000): консоль FireBug не покажет вам более 190 вложенных массивов, но они есть

Java, 88 107 105 104 102 байта

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

Довольно долго по сравнению с другими, хотя с Java вы не сможете добиться большего успеха. Проверка, чтобы определить, продолжать ли рекурсию, - это все, что нужно.

Python 2, 56 байт

Я подозреваю, что это может быть в гольфе больше.

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

тесты:

# 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 байт

Я знаю, что Оптимизатор нашел 16, но вот лучшее, что я могу сделать:

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

Это блок, наиболее близкий к функции в CJam, которая берет целое число в стеке и оставляет желаемый вложенный массив.

Используйте эту программу для проверки , которая помещает входные данные в стек, затем вызывает функцию и проверяет стек. Обратите внимание, что для 0, вывод стека будет содержать ""- это собственное представление CJam пустого массива.

Руби 46

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

Проверьте это онлайн: http://ideone.com/uYRVTa

C # - 100

Простая рекурсия. Проверьте нулевой особый случай и отметьте одну переменную, а другую -

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

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

Это замечательно, я имею в виду византийский, но это та же основная идея, что и C # один.

Это реализация массива в стиле C, поэтому он не дает вам массив, он дает указатель на int, в котором я хранил как int, так и другие указатели. Так:[0,*] *->[1,#] #-> [2,&] &-> etc где символы представляют собой псевдокод значения int для указателя, а -> - это место, куда он указывает в памяти.

Какую превосходную простую в использовании реализацию зубчатых массивов в стиле c я разработал (кашель), но я утверждаю, что это достаточно правдоподобно, чтобы соответствовать правилам вопроса.

Здесь довольно много злоупотреблений троичными операторами, а также довольно много злоупотреблений неявным приведением от int к bool.

Пример: если мы позволим int *bar = (int*)A(3);, мы можем увидеть:

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

Что является указателем разговора для [0, [1, [2]]].

В порядке прекрасно. На самом деле это не должно быть ужасно. Вот некоторый тестовый код для запуска этого кода C ++:

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

}

Pyth, 15 байт

?u[HG)_UtQ]tQQY

Что действительно говорит в 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 байт

Эти вложенные списки имеют ту же структуру данных, что и корневые Trees, за исключением того, что они также могут быть пустыми. Следовательно, мы можем использовать их список - также называемый a, Forestчтобы представлять их.

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

Попробуйте онлайн!

объяснение

Прежде всего нам нужно реализовать Treeтип данных:

data Tree = Node [Tree] Int

Оттуда это просто рекурсия, использующая два параметра m(считая) и nотслеживая, когда завершить:

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

Альтернатива, 61 байт

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

Попробуйте онлайн!

объяснение

Функция unfoldForestпринимает список начальных значений и функцию x -> (y,[x]). Для каждого начального значения xоно разворачивает дерево, используя функцию, создавая кортеж, (y,xs)где yон становится корнем и xsиспользуется для повторения процедуры:

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}

Добавлю объяснения по запросу. Вы можете попробовать это здесь .

JavaScript, 93 байта

Это не идеально, но я мог бы попробовать. Я попробую сыграть в эту игру позже, хотя пока я не вижу очевидного пути.

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

Python, 75 байт

Это просто для галочки. Это программа, которую я написал при создании / разработке этого задания.

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]

Python, 44

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

Рекурсивно создает дерево. В [:n]конце приведен специальный случай, n==0в котором указан пустой список.

Джо , 8 байт

Примечание: это неконкурентный ответ. Первая версия Джо была выпущена после этого вопроса.

F:/+,M]R

Что же мы имеем здесь? F:определяет функцию F, которая является цепочкой /+,, M]и R. Когда вы звоните Fn, сначала Rnоценивается, возвращая диапазон от 0 до n, исключая. M]оборачивает каждый элемент в список. Затем список применяется к /+,. x +, y возвращается x + [y]. /это правильная складка. Таким образом, /+,a b c d...возвращается [a, [b, [c, [d...]]].

Пример вызова (код имеет отступ 3, вывод 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 - рекурсивная версия - 52

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

Нерекурсивная версия: 66 62 57

r=->i{(i-1).downto(0).inject(nil){|a,n|a ?[n,a]:[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]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Нерекурсивная версия может обрабатывать произвольно большой ввод.

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

Обе версии также изящно принимают отрицательные числа

p r[-5] # => []

PHP 5.4 (67 байт):

Знаю, знаю.

Это далеко не самый короткий ответ.

Но это работает!

Вот:

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

Вы можете проверить это прямо здесь: https://ideone.com/42L35E (игнорируйте ошибку)

Javascript (57 байт):

Это тот же самый точный код за исключением того, что Javascript требователен к возврату, и я сократил имена переменных:

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

Видеть? Тот же код!

ES6 (49 байт):

В основном тот же самый точный код, но сокращенный для ES6:

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

Javascript (114 байт):

Все остальные делали рекурсивные действия, поэтому я хотел попробовать итеративное решение. У меня слишком много особых случаев.

Я держу основной список, а затем зацикливаю и добавляю новые списки с новыми номерами.

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}

Common Lisp (95 байт):

(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 байт

Рекурсивное решение

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

Попробуйте онлайн!

05AB1E , 11 байт

_i¯ëFNI<α)R

Попробуйте онлайн или проверьте все контрольные примеры .

11-байтовая альтернатива:

_i¯ëݨRvy)R

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

05AB1E не имеет циклов, которые идут вниз, поэтому для цикла в диапазоне (input, 0]я должен либо:

• Сначала создайте этот диапазон ( ݨRсоздайте диапазон [0, input], удалите последний элемент, поверните вспять), а затем зациклите его (vy );
• [0, input)Вместо этого используйте цикл в диапазоне ( F) и возьмите абсолютную разницу между индексом цикла и значением input-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)