Wyzwanie polega po prostu na zwróceniu listy liczb całkowitych, podobnej do funkcji zakresu Pythona, z tym wyjątkiem, że każda kolejna liczba musi znajdować się tak głęboko na listach.

Zasady :

• Utwórz program lub funkcję nieanonimową
• Powinien zwrócić lub wydrukować wynik
• Wynik należy zwrócić w postaci listy (list) lub tablicy (tablic)
• Jeśli parametr wynosi zero, zwróć pustą listę
• Powinno to być w stanie obsłużyć wartość całkowitą parametru 0 <= n <70.
  • (rozwiązania rekurencyjne wybuchają dość szybko)
• Funkcja powinna być możliwa do wywołania za pomocą tylko jednego parametru.
• Inne zachowanie jest niezdefiniowane.
• To jest kod golfowy, więc wygrywa najkrótszy kod.

Przykładowe połączenie:

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

Przypadki testowe:

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

EDYCJA: odpowiedź Isaacga jest najkrótsza jak dotąd. Zaktualizuję zaakceptowaną odpowiedź, jeśli ktoś znajdzie krótszy w języku, który istniał w momencie opublikowania wyzwania. Dzięki za grę!

Pyth, 13 bajtów

?hu]+HG_UQYQY

Wypróbuj tutaj.

                 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)

Zakładając ⎕IO=0:

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

Wyjaśnienie:

• ×⍵:jeśli ⍵jest pozytywny,
  • ,∘⊂∘,: dołącz lewy operand do otaczania prawego operandu (tj. x ,∘⊂∘, y = [x, [y]])
  • /: redukować
  • ⍳⍵: liczby 0..⍵-1
  • ⊃: ujawnij wynik
• ⋄: Inaczej
  • ⍬: zwraca pustą listę
  • (jest to konieczne, ponieważ /kończy się niepowodzeniem ⍬i ⍳0daje pustą listę).

Uzupełnienie:

Ta funkcja zwraca tablicę zagnieżdżoną. Jednak trudno jest to stwierdzić na podstawie domyślnego wyjścia APL. Oddziela elementy tablicy od spacji, dzięki czemu można rozpoznać zagnieżdżanie tylko przez podwójne spacje. Oto funkcja, która pobierze zagnieżdżoną tablicę i zwróci ciąg znaków, formatując zagnieżdżoną tablicę w stylu Pythona (tj [a,[b,[c,...]]].).

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

Haskell, 67 bajtów

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

W Haskell wszystkie elementy listy muszą być tego samego typu, więc nie mogę mieszać liczb całkowitych z listą liczb całkowitych i muszę zdefiniować niestandardowy typ listy L. Funkcja pomocnicza #rekurencyjnie tworzy wymaganą listę. Główna funkcja psprawdza pustą listę i w #przeciwnym razie wywołuje .

Ponieważ nowe typy danych nie mogą być drukowane domyślnie (reguły zezwalają tylko na zwrócenie listy), dodaję trochę kodu dla celów demonstracyjnych:

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

Teraz:

-- 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 bajtów

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

Używanie mnożenia listy do obsługi specjalnego przypadku.

Mathematica, 33

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

CJam, 16 bajtów

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

To jest pełny program. Pobiera dane wejściowe przez STDIN i drukuje ostatnią tablicę na STDOUT.

Podobnie jak w przypadku innych pozycji CJam, 0dane wejściowe zostaną wydrukowane, ""ponieważ jest to reprezentacja pustej tablicy w CJam.

Jak to działa :

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

Wypróbuj online tutaj

JavaScript (ES6) 40

Rozwiązanie rekurencyjne, dość solidne, bez ciosów. Aktualizacja kończy się niepowodzeniem w okolicach 6500 z „zbyt dużą rekurencją”

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

Rozwiązanie iteracyjne (45) Bez ograniczeń oprócz użycia pamięci

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

Wypróbuj F (1000): konsola FireBug nie wyświetli więcej niż 190 zagnieżdżonych tablic, ale one tam są

Java, 88 107 105 104 102 bajtów

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

Dość długo w porównaniu do innych, choć Java nie da się lepiej. Wystarczy sprawdzić, czy kontynuować rekurencję.

Python 2, 56 bajtów

Podejrzewam, że można by bardziej zagrać w golfa.

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

Testy:

# 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 bajtów

Wiem, że Optymalizator znalazł 16, ale oto najlepsze, co mogę zrobić:

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

Jest to blok najbliższy funkcji w CJam, która przyjmuje liczbę całkowitą na stos i pozostawia żądaną zagnieżdżoną tablicę.

Użyj tego programu do przetestowania go , który umieszcza dane wejściowe na stosie, a następnie wywołuje funkcję i sprawdza stos. Zauważ, że dla 0, wyjście stosu będzie zawierać ""- jest to natywna reprezentacja pustej tablicy przez CJam.

Rubinowy 46

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

Przetestuj online: http://ideone.com/uYRVTa

C # - 100

Prosta rekurencja. Sprawdź zerowy przypadek specjalny i zaznacz jedną zmienną w górę, drugą w dół

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

Ten jest świetny, przez co rozumiem bizantynę, ale jest to ten sam podstawowy pomysł, co c # one.

Jest to implementacja tablicy w stylu C, więc nie daje ci tablicy, daje wskaźnik int, w którym przechowywałem zarówno ints, jak i inne wskaźniki. W ten sposób: [0,*] *->[1,#] #-> [2,&] &-> etcgdzie symbole są pseudo kodem wartości int wskaźnika, a -> wskazuje miejsce w pamięci.

Cóż za doskonała, łatwa w użyciu implementacja poszarpanych tablic w stylu c (kaszel), ale uważam, że jest wystarczająco prawdopodobna, aby była zgodna z regułami pytania.

Jest tu całkiem sporo nadużywających operatorów trójskładnikowych, a także sporo nadużywania niejawnej obsady od int do bool.

Przykład: jeśli pozwolimy int *bar = (int*)A(3);, możemy zobaczyć:

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

Który jest wskaźnikiem dla [0, [1, [2]]].

Ok dobrze. To wcale nie musi być okropne. Oto kod testowy do uruchomienia tego kodu 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 bajtów

?u[HG)_UtQ]tQQY

Co tak naprawdę mówi w Pythonie:

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 bajtów

Te zagnieżdżone listy mają tę samą strukturę danych co zrootowane Trees, z tym że mogą być również puste. Dlatego możemy użyć ich listy - zwanej także a, Forestaby je reprezentować.

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

Wypróbuj online!

Wyjaśnienie

Przede wszystkim musimy zaimplementować Treetyp danych:

data Tree = Node [Tree] Int

Stamtąd jest to po prostu rekurencja przy użyciu dwóch parametrów m(zliczanie w górę) i nśledzenie, kiedy należy zakończyć:

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

Alternatywnie, 61 bajtów

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

Wypróbuj online!

Wyjaśnienie

Funkcja unfoldForestprzyjmuje listę wartości początkowych i funkcję x -> (y,[x]). Dla każdej wartości początkowej xto rozwija drzewa przy użyciu funkcji, tworząc krotki (y,xs)gdzie ystaną korzeń i xssą wykorzystywane, aby powtórzyć procedurę:

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}

Na żądanie doda wyjaśnienie. Możesz spróbować tutaj .

JavaScript, 93 bajty

To nie jest idealne, ale równie dobrze mogę spróbować. Później spróbuję zagrać w golfa, choć na razie nie widzę oczywistego sposobu.

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

Python, 75 bajtów

To tylko na pokaz. Jest to program, który napisałem podczas tworzenia / projektowania tego wyzwania.

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]

Rekurencyjnie tworzy drzewo. Na [:n]koniec należy w specjalnym przypadku n==0podać pustą listę.

Joe , 8 bajtów

Uwaga: to jest niekonkurencyjna odpowiedź. Pierwsza wersja Joe została wydana po tym pytaniu.

F:/+,M]R

Co my tu mamy? F:określa funkcji F, która jest łańcuch /+,, M]a R. Kiedy zadzwonisz Fn, najpierw Rnzostanie oceniony, zwracając zakres od 0 do n, wyłącznie. M]zawija każdy element do listy. Następnie stosowana jest lista /+,. x +, y zwraca x + [y]. /jest prawy pas. Tak więc /+,a b c d...powraca [a, [b, [c, [d...]]].

Przykładowe wywołania (kod jest wcięty przez 3, a wynik przez 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 - wersja rekurencyjna - 52

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

Wersja nierekurencyjna: 66 62 57

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

Przykładowe dane wyjściowe (takie same dla obu wersji)

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

Wersja nierekurencyjna może obsługiwać dowolnie duże dane wejściowe.

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

Obie wersje z wdzięcznością przyjmują również liczby ujemne

p r[-5] # => []

PHP 5.4 (67 bajtów):

Wiem wiem.

Nie jest to najkrótsza odpowiedź.

Ale to działa!

Oto on:

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

Możesz to przetestować tutaj: https://ideone.com/42L35E (zignoruj ​​błąd)

JavaScript (57 bajtów):

To jest dokładnie ten sam kod, z tym wyjątkiem, że JavaScript jest wybredny w kwestii zwrotu i zredukowałem nazwy zmiennych:

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

Widzieć? Ten sam kod!

ES6 (49 bajtów):

Zasadniczo ten sam dokładny kod, ale zmniejszony dla ES6:

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

JavaScript (114 bajtów):

Wszyscy inni robili rekurencję, więc chciałem wypróbować iteracyjne rozwiązanie. Mam jednak zbyt wiele specjalnych przypadków.

Trzymam główną listę, a następnie zapętlam i dołączam nowe listy z nowymi numerami.

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 bajtów):

(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 bajtów

Rozwiązanie rekurencyjne

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

Wypróbuj online!

05AB1E , 11 bajtów

_i¯ëFNI<α)R

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

11-bajtowa alternatywa:

_i¯ëݨRvy)R

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

05AB1E nie ma pętli, które schodzą w dół, więc aby zapętlić zakres, (input, 0]muszę albo:

• Najpierw utwórz ten zakres ( ݨR; utwórz zakres [0, input], usuń ostatni element, odwróć), a następnie zapętl go ( vy);
• Lub zapętl się w zakresie [0, input)zamiast ( F) i weź absolutną różnicę między indeksem pętli a wejściem 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)