Ce défi consiste simplement à renvoyer une liste de listes d'entiers, semblable à la fonction de plage Python, sauf que chaque numéro successif doit être aussi profond que cela dans les listes.

Règles :

• Créer un programme ou une fonction non anonyme
• Il doit retourner ou imprimer le résultat
• Le résultat doit être retourné dans une liste (de listes) ou un tableau (de tableaux)
• Si le paramètre est zéro, renvoyez une liste vide
• Cela devrait être capable de gérer un paramètre entier 0 <= n <70.
  • (les solutions récursives explosent assez rapidement)
• La fonction doit pouvoir être appelée avec un seul paramètre.
• Les autres comportements ne sont pas définis.
• C'est le golf de code, donc le code le plus court gagne.

Exemple d'appel:

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

Cas de 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 réponse d'isaacg est la plus courte jusqu'à présent. Je mettrai à jour la réponse acceptée si quelqu'un en trouve une plus courte dans une langue qui existait lors de la publication du défi. Merci d'avoir joué!

Pyth, 13 octets

?hu]+HG_UQYQY

Essayez-le ici.

                 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)

En supposant ⎕IO=0:

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

Explication:

• ×⍵:si ⍵est positif,
  • ,∘⊂∘,: joindre l'opérande gauche à la clôture de l'opérande droit (ie x ,∘⊂∘, y = [x, [y]])
  • /: réduire
  • ⍳⍵: les nombres 0..⍵-1
  • ⊃: dévoiler le résultat
• ⋄: autrement
  • ⍬: retourne la liste vide
  • (Ceci est nécessaire car /échoue ⍬et ⍳0donne la liste vide.)

Addenda:

Cette fonction renvoie un tableau imbriqué. Cependant, il est un peu difficile de le dire à partir de la sortie par défaut d'APL. Il sépare les éléments du tableau par des espaces, vous ne pouvez donc dire l'imbrication que par des espaces doubles. Voici une fonction qui prendra un tableau imbriqué et retournera une chaîne, formatant le tableau imbriqué en style Python (ie [a,[b,[c,...]]]).

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

Haskell, 67 octets

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

Dans Haskell, tous les éléments d'une liste doivent être du même type, je ne peux donc pas mélanger des entiers avec une liste d'entiers et je dois définir un type de liste personnalisé L. La fonction d'assistance #construit récursivement la liste requise. La fonction principale pvérifie la liste vide et appelle #autrement.

Comme les nouveaux types de données ne peuvent pas être imprimés par défaut (les règles permettent juste de renvoyer la liste), j'ajoute un peu plus de code à des fins de démonstration:

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

À présent:

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

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

Utilisation de la multiplication de listes pour gérer le cas spécial.

Mathematica, 33

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

CJam, 16 octets

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

Ceci est un programme complet. Il prend l'entrée via STDIN et imprime le tableau final sur STDOUT.

Comme pour l'autre entrée CJam, l' 0entrée sera imprimée ""car c'est la représentation d'un tableau vide dans CJam.

Comment ça marche :

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

Essayez-le en ligne ici

JavaScript (ES6) 40

Solution récursive, assez robuste, pas de coups. La mise à jour échoue près de 6500 avec «trop de récursivité»

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

Solution itérative (45) Aucune limite, sauf l'utilisation de la mémoire

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

Essayez F (1000): la console FireBug ne vous montrera pas plus de 190 tableaux imbriqués, mais ils sont là

Java, 88 107 105 104 102 octets

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

Assez long par rapport aux autres, bien que vous ne puissiez pas faire beaucoup mieux avec Java. Une vérification pour déterminer s'il faut continuer la récursivité est tout ce qu'il faut.

Python 2, 56 octets

Je soupçonne que cela pourrait être joué davantage.

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

Tests:

# 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 octets

Je sais que Optimizer en a trouvé 16, mais voici ce que je peux faire de mieux:

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

Il s'agit d'un bloc, la chose la plus proche d'une fonction dans CJam, qui prend un entier sur la pile et laisse le tableau imbriqué souhaité.

Utilisez ce programme pour le tester , ce qui place l'entrée sur la pile, puis appelle la fonction et inspecte la pile. Notez que pour 0la sortie de la pile contiendra ""- c'est une représentation native d'un tableau vide de CJAM.

Rubis 46

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

Testez-le en ligne: http://ideone.com/uYRVTa

C # - 100

Récursivité simple. Vérifiez le cas spécial zéro et cochez avec une variable, vers le bas avec l'autre

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

Celui-ci est génial, j'entends par byzantin, mais c'est la même idée de base que le c # one.

C'est une implémentation de tableau de style C, donc elle ne vous donne pas de tableau, elle donne un pointeur int, dans lequel je stockais à la fois des entiers et d'autres pointeurs. Comme ça:[0,*] *->[1,#] #-> [2,&] &-> etc où les symboles sont un pseudo-code pour la valeur int d'un pointeur et le -> où il pointe en mémoire.

Quelle excellente implémentation facile à utiliser des tableaux irréguliers de style c que j'ai imaginée (toux), mais je maintiens qu'elle est suffisamment plausible pour être dans les règles de la question.

Il y a beaucoup d'abus d'opérateurs ternaires ici, et aussi beaucoup d'abus de la distribution implicite de int à bool.

Exemple: si nous le laissons int *bar = (int*)A(3);, nous pouvons voir:

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

Ce qui est un pointeur parler pour [0, [1, [2]]].

D'accord, très bien. Il n'est pas nécessaire que ce soit horrible. Voici un code de test pour exécuter ce code 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 octets

?u[HG)_UtQ]tQQY

Ce qui veut vraiment dire, en 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 octets

Ces listes imbriquées ont la même structure de données que les Trees enracinées , sauf qu'elles peuvent également être vides. Par conséquent, nous pouvons utiliser une liste d'entre eux - également appelée a Forestpour les représenter.

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

Essayez-le en ligne!

Explication

Tout d'abord, nous devons implémenter le Treetype de données:

data Tree = Node [Tree] Int

À partir de là, il ne s'agit que de récursivité en utilisant deux paramètres m(comptage) et nde garder une trace quand terminer:

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

Alternative, 61 octets

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

Essayez-le en ligne!

Explication

La fonction unfoldForestprend une liste de valeurs initiales et une fonction x -> (y,[x]). Pour chaque valeur initiale, xil déplie un arbre à l'aide de la fonction, produisant un tuple (y,xs)où ydeviendra la racine et xssont utilisés pour répéter la procédure:

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}

Ajoutera une explication sur demande. Vous pouvez l'essayer ici .

JavaScript, 93 octets

Ce n'est pas idéal, mais je pourrais aussi bien essayer. Je vais essayer de jouer au golf plus tard, mais pour l'instant je ne vois aucun moyen évident de le faire.

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

Python, 75 octets

C'est juste pour le spectacle. C'est le programme que j'ai écrit lors de la création / conception de ce défi.

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]

Crée récursivement l'arbre. La [:n]fin est de cas particulier n==0en donnant la liste vide.

Joe , 8 octets

Remarque: Il s'agit d'une réponse non concurrente. La première version de Joe est sortie après cette question.

F:/+,M]R

Qu'avons-nous ici? F:définit une fonction F qui est une chaîne de /+,, M]et R. Lorsque vous appelez Fn, le premier Rnest évalué, renvoyant la plage de 0 à n, exclusif. M]enveloppe chaque élément dans une liste. Ensuite, la liste est appliquée à /+,. x +, y retourne x + [y]. /est un pli droit. Ainsi, /+,a b c d...revient [a, [b, [c, [d...]]].

Exemples d'appels (le code est indenté par 3, sortie par 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 - Version récursive - 52

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

Version non récursive: 66 62 57

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

Exemple de sortie (identique pour les deux versions)

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 version non récursive peut gérer des entrées arbitrairement grandes.

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

Les deux versions acceptent également gracieusement les nombres négatifs

p r[-5] # => []

PHP 5.4 (67 octets):

Je sais je sais.

C'est loin d'être la réponse la plus courte.

Mais ça marche!

C'est ici:

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

Vous pouvez le tester ici: https://ideone.com/42L35E (ignorer l'erreur)

Javascript (57 octets):

C'est le même code exact sauf que Javascript est pointilleux sur le retour et j'ai réduit les noms de variables:

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

Voir? Même code!

ES6 (49 octets):

Fondamentalement, le même code exact, mais réduit pour ES6:

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

Javascript (114 octets):

Tout le monde faisait du récursif, donc je voulais essayer une solution itérative. J'ai cependant trop de cas particuliers.

Je tiens une liste principale, puis je boucle et j'ajoute de nouvelles listes avec de nouveaux numéros.

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 commun (95 octets):

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

Solution récursive

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

Essayez-le en ligne!

05AB1E , 11 octets

_i¯ëFNI<α)R

Essayez-le en ligne ou vérifiez tous les cas de test .

Alternative de 11 octets:

_i¯ëݨRvy)R

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

05AB1E n'a pas de boucles qui descendent, donc pour boucler dans la plage, (input, 0]je dois:

• Créez d'abord cette plage ( ݨR; créez la plage [0, input], supprimez le dernier élément, inversez), puis bouclez dessus ( vy);
• Ou bouclez dans la plage à la [0, input)place ( F) et prenez la différence absolue entre l'index de boucle et l'entrée-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)