Questa sfida è semplicemente quella di restituire un elenco di elenchi di numeri interi, simile alla funzione di intervallo Python, tranne per il fatto che ogni numero successivo deve essere così profondo negli elenchi.

Regole :

• Crea un programma o una funzione non anonima
• Dovrebbe restituire o stampare il risultato
• Il risultato deve essere restituito in un elenco (di elenchi) o in una matrice (di array)
• Se il parametro è zero, restituisce un elenco vuoto
• Questo dovrebbe essere in grado di gestire un parametro intero 0 <= n <70.
  • (le soluzioni ricorsive esplodono abbastanza velocemente)
• La funzione dovrebbe essere richiamabile con un solo parametro.
• Altri comportamenti non sono definiti.
• Questo è il golf del codice, quindi vince il codice più corto.

Esempio di chiamata:

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

Casi test:

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: la risposta di isaacg è la più breve finora. Aggiornerò la risposta accettata se qualcuno ne trova una più breve in una lingua esistente al momento della pubblicazione della sfida. Grazie per aver giocato!

Pyth, 13 byte

?hu]+HG_UQYQY

Provalo qui.

                 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)

Supponendo ⎕IO=0:

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

Spiegazione:

• ×⍵:se ⍵è positivo,
  • ,∘⊂∘,: unisce l'operando di sinistra al racchiudere l'operando di destra (cioè x ,∘⊂∘, y = [x, [y]])
  • /: ridurre
  • ⍳⍵: i numeri 0..⍵-1
  • ⊃: rivelare il risultato
• ⋄: altrimenti
  • ⍬: restituisce l'elenco vuoto
  • (questo è necessario perché /non funziona ⍬e ⍳0fornisce un elenco vuoto.)

Addendum:

Questa funzione restituisce un array nidificato. Tuttavia, è un po 'difficile dirlo dall'output predefinito di APL. Separa gli elementi dell'array per spazi, in modo da poter distinguere solo i doppi spazi. Ecco una funzione che prenderà un array nidificato e restituirà una stringa, formattando l'array nidificato in stile Python (cioè [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

In Haskell tutti gli elementi di un elenco devono essere dello stesso tipo, quindi non posso mescolare numeri interi con elenco di numeri interi e devo definire un tipo di elenco personalizzato L. La funzione helper #costruisce ricorsivamente l'elenco richiesto. La funzione principale pcontrolla l'elenco vuoto e chiama# altrimenti.

Poiché i nuovi tipi di dati non possono essere stampati per impostazione predefinita (le regole consentono solo di restituire l'elenco), aggiungo altro codice a scopo dimostrativo:

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

Adesso:

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

Utilizzo della moltiplicazione dell'elenco per gestire il caso speciale.

Mathematica, 33

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

CJam, 16 byte

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

Questo è un programma completo. Prende l'input tramite STDIN e stampa l'array finale su STDOUT.

Come con l'altra voce di CJam, l' 0input verrà stampato ""come quella rappresentata da un array vuoto in CJam.

Come funziona :

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

Provalo online qui

JavaScript (ES6) 40

Soluzione ricorsiva, abbastanza robusta, senza colpi. L'aggiornamento non è vicino a 6500 con "troppa ricorsione"

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

Soluzione iterativa (45) Nessun limite tranne l'utilizzo della memoria

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

Prova F (1000): la console FireBug non mostrerà più di 190 array nidificati, ma sono lì

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

Abbastanza a lungo rispetto agli altri, anche se non puoi fare molto meglio con Java. Un controllo per determinare se continuare la ricorsione è tutto ciò che serve.

Python 2, 56 byte

Ho il sospetto che questo potrebbe essere golfato di più.

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

test:

# 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

So che Optimizer ha trovato 16, ma ecco il meglio che posso fare:

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

Questo è un blocco, la cosa più vicina a una funzione in CJam, che accetta un numero intero nello stack e lascia l'array nidificato desiderato.

Utilizzare questo programma per testarlo , che inserisce l'input nello stack, quindi chiama la funzione e ispeziona lo stack. Si noti che per 0, l'output dello stack conterrà "": questa è la rappresentazione nativa di CJam di un array vuoto.

Ruby 46

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

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

C # - 100

Ricorsione semplice. Controllare il caso speciale zero e spuntare con una variabile, verso il basso con l'altra

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

Questo è fantastico, con questo intendo bizantino, ma è la stessa idea di base del c # one.

È un'implementazione di array in stile C, quindi non ti dà un array, ma fornisce un puntatore int, in cui stavo memorizzando sia ints che altri puntatori. In questo modo:, [0,*] *->[1,#] #-> [2,&] &-> etcdove i simboli sono pseudo-codice per il valore int di un puntatore e -> è dove si trova il puntatore in memoria.

Che eccellente implementazione facile da usare di array frastagliati in stile c che ho ideato (tosse), ma sostengo che sia abbastanza plausibile da essere all'interno delle regole della domanda.

Ci sono molti abusi degli operatori ternari qui, e anche molti abusi del cast implicito da int a bool.

Esempio: se permettiamo int *bar = (int*)A(3);, possiamo vedere:

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

Qual è il discorso del puntatore per [0, [1, [2]]].

Ok bene. In realtà non deve essere il terribile. Ecco un po 'di codice di prova per eseguire questo codice 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 byte

?u[HG)_UtQ]tQQY

Il che sta davvero dicendo, in 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

Questi elenchi nidificati hanno la stessa struttura di dati dei rooted Tree, tranne che possono anche essere vuoti. Quindi, possiamo usarne un elenco, chiamato anche a Forestper rappresentarli.

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

Provalo online!

Spiegazione

Prima di tutto dobbiamo implementare il Treetipo di dati:

data Tree = Node [Tree] Int

Da lì è solo la ricorsione utilizzando due parametri m(conteggio in avanti) e nper tenere traccia di quando terminare:

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

Alternativa, 61 byte

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

Provalo online!

Spiegazione

La funzione unfoldForestaccetta un elenco di valori iniziali e una funzione x -> (y,[x]). Per ogni valore iniziale xsi sviluppa un albero usando la funzione, producendo una tupla (y,xs)dove ydiventerà la radice e xsverranno usati per ripetere la procedura:

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}

Aggiungerà spiegazione su richiesta. Puoi provarlo qui .

JavaScript, 93 byte

Questo non è l'ideale, ma potrei anche provarlo. Proverò a giocare a golf più avanti, anche se per ora non vedo un modo ovvio per farlo.

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

Python, 75 byte

Questo è solo per lo spettacolo. È il programma che ho scritto durante la creazione / progettazione di questa sfida.

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]

Crea ricorsivamente l'albero. Alla [:n]fine è il caso speciale n==0nel dare la lista vuota.

Joe , 8 byte

Nota: questa è una risposta non competitiva. La prima versione di Joe è stata rilasciata dopo questa domanda.

F:/+,M]R

Cosa abbiamo qui? F:definisce una funzione F che è una catena di /+,, M]e R. Quando chiami Fn, Rnviene prima valutato, restituendo un intervallo da 0 a n, esclusivo. M]avvolge ogni elemento in un elenco. Quindi l'elenco viene applicato a /+,. x +, y ritorna x + [y]. /è una piega a destra. Quindi, /+,a b c d...ritorna[a, [b, [c, [d...]]] .

Invocazioni di esempio (il codice è indentato da 3, emesso da 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 - Versione ricorsiva - 52

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

Versione non ricorsiva: 66 62 57

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

Output di esempio (uguale per entrambe le versioni)

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

La versione non ricorsiva può gestire input arbitrariamente grandi.

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

Entrambe le versioni accettano anche con grazia numeri negativi

p r[-5] # => []

PHP 5.4 (67 byte):

Lo so, lo so.

È lungi dall'essere la risposta più breve.

Ma funziona!

Ecco qui:

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

Puoi provarlo qui: https://ideone.com/42L35E (ignora l'errore)

Javascript (57 byte):

Questo è lo stesso codice esatto tranne per il fatto che Javascript è pignolo per il ritorno e ho ridotto i nomi delle variabili:

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

Vedere? Stesso codice!

ES6 (49 byte):

Fondamentalmente lo stesso codice esatto, ma ridotto per ES6:

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

Javascript (114 byte):

Tutti gli altri stavano facendo ricorsivi, quindi volevo provare una soluzione iterativa. Ho troppi casi speciali, però.

Tengo un elenco principale, quindi eseguo il ciclo e aggiungo nuovi elenchi con nuovi numeri.

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

Soluzione ricorsiva

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

Provalo online!

05AB1E , 11 byte

_i¯ëFNI<α)R

Provalo online o verifica tutti i casi di test .

Alternativa a 11 byte:

_i¯ëݨRvy)R

Provalo online o verifica tutti i casi di test .

Spiegazione:

05AB1E non ha loop che vanno verso il basso, quindi per loop nella gamma (input, 0] devo o:

• Crea prima quell'intervallo ( ݨR; crea un intervallo [0, input], rimuovi l'ultimo elemento, inverti), quindi passa sopra di esso (vy );
• Oppure fai un ciclo nell'intervallo [0, input)invece ( F) e prendi la differenza assoluta tra l'indice del ciclo e l'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)