Este desafío es simplemente devolver una lista de listas de enteros, similar a la función de rango de Python, excepto que cada número sucesivo debe ser tan profundo en las listas.

reglas :

• Crear un programa o una función no anónima
• Debería devolver o imprimir el resultado
• El resultado debe devolverse en una lista (de listas) o matriz (de matrices)
• Si el parámetro es cero, devuelve una lista vacía
• Esto debería ser capaz de manejar un parámetro entero 0 <= n <70.
  • (Las soluciones recursivas explotan bastante rápido)
• La función debe ser invocable con solo un parámetro.
• Otro comportamiento es indefinido.
• Este es el código de golf, por lo que gana el código más corto.

Llamada de ejemplo:

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

Casos de prueba:

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

EDITAR: la respuesta de Isaac es la más corta hasta ahora. Actualizaré la respuesta aceptada si alguien encuentra una más corta en un idioma que existía en la publicación del desafío. ¡Gracias por jugar!

Pyth, 13 bytes

?hu]+HG_UQYQY

Pruébalo aquí

                 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)

Asumiendo ⎕IO=0:

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

Explicación:

• ×⍵:si ⍵es positivo
  • ,∘⊂∘,: une el operando izquierdo al encerramiento del operando derecho (es decir x ,∘⊂∘, y = [x, [y]])
  • /: reducir
  • ⍳⍵: los números 0..⍵-1
  • ⊃: revelar el resultado
• ⋄: de lo contrario
  • ⍬: devuelve la lista vacía
  • (esto es necesario porque /falla ⍬y ⍳0da la lista vacía).

Apéndice:

Esta función devuelve una matriz anidada. Sin embargo, es un poco difícil distinguir esto de la salida predeterminada de APL. Separa los elementos de la matriz por espacios, por lo que solo puede distinguir la anidación por espacios dobles. Aquí hay una función que tomará una matriz anidada y devolverá una cadena, formateando la matriz anidada en estilo Python (es decir [a,[b,[c,...]]]).

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

Haskell, 67 bytes

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

En Haskell, todos los elementos de una lista deben ser del mismo tipo, por lo que no puedo mezclar enteros con la lista de enteros y tengo que definir un tipo de lista personalizada L. La función auxiliar #construye recursivamente la lista requerida. La función principal pverifica la lista vacía y llama de #otra manera.

Como los nuevos tipos de datos no se pueden imprimir de forma predeterminada (las reglas solo permiten devolver la lista), agrego un poco más de código para fines de demostración:

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

Ahora:

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

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

Usando la multiplicación de listas para manejar el caso especial.

Mathematica, 33

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

CJam, 16 bytes

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

Este es un programa completo. Toma entrada a través de STDIN e imprime la matriz final en STDOUT.

Al igual que con la otra entrada de CJam, la 0entrada se imprimirá ""ya que es la representación de una matriz vacía en CJam.

Cómo funciona :

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

Pruébalo en línea aquí

JavaScript (ES6) 40

Solución recursiva, bastante robusta, sin golpes. La actualización falla cerca de 6500 con 'demasiada recursividad'

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

Solución iterativa (45) Sin límites, excepto el uso de memoria

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

Pruebe F (1000): la consola FireBug no le mostrará más de 190 matrices anidadas, pero están allí

Java, 88 107 105 104 102 bytes

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

Bastante largo en comparación con los demás, aunque no puedes hacerlo mucho mejor con Java. Una verificación para determinar si continuar la recursión es todo lo que se necesita.

Python 2, 56 bytes

Sospecho que esto podría jugar más golf.

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

Pruebas:

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

Sé que Optimizer ha encontrado 16, pero aquí está lo mejor que puedo hacer:

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

Este es un bloque, lo más parecido a una función en CJam, que toma un número entero en la pila y deja la matriz anidada deseada.

Use este programa para probarlo , que coloca la entrada en la pila, luego llama a la función e inspecciona la pila. Tenga en cuenta que para 0, la salida de la pila contendrá "": esta es la representación nativa de CJam de una matriz vacía.

Ruby 46

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

Pruébelo en línea: http://ideone.com/uYRVTa

C # - 100

Recurrencia simple Marque el caso especial cero y marque con una variable, abajo con la otra

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

Este es genial, con lo que quiero decir bizantino, pero es la misma idea básica que el c # uno.

Es una implementación de matriz de estilo C, por lo que no le da una matriz, le da un puntero int, en el que estaba almacenando entradas y otros punteros. De esta manera:, [0,*] *->[1,#] #-> [2,&] &-> etcdonde los símbolos son pseudocódigo para el valor int de un puntero y el -> es donde apunta en la memoria.

Qué excelente implementación fácil de usar de arreglos irregulares estilo c que he ideado (tos), pero mantengo que es lo suficientemente plausible como para estar dentro de las reglas de la pregunta.

Aquí hay muchos operadores ternarios abusadores, y también mucho abuso del elenco implícito de int a bool.

Ejemplo: si dejamos int *bar = (int*)A(3);, podemos ver:

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

Que es la charla de puntero para [0, [1, [2]]].

Bien vale. En realidad no tiene que ser horrible. Aquí hay un código de prueba para ejecutar este código 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 bytes

?u[HG)_UtQ]tQQY

Lo que realmente dice, 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 bytes

Estas listas anidadas tienen la misma estructura de datos que las raíz Tree, excepto que también pueden estar vacías. Por lo tanto, podemos usar una lista de ellos, también llamada a Forestpara representarlos.

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

Pruébalo en línea!

Explicación

En primer lugar, necesitamos implementar el Treetipo de datos:

data Tree = Node [Tree] Int

A partir de ahí, es solo recursión utilizando dos parámetros m(contando hacia arriba) y nhacer un seguimiento de cuándo terminar:

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

Alternativa, 61 bytes

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

Pruébalo en línea!

Explicación

La función unfoldForesttoma una lista de valores iniciales y una función x -> (y,[x]). Para cada valor inicial x, despliega un árbol usando la función, produciendo una tupla (y,xs)donde yse convertirá en la raíz y xsse usará para repetir el procedimiento:

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}

Agregará una explicación a pedido. Puedes probarlo aquí .

JavaScript, 93 bytes

Esto no es ideal, pero podría intentarlo. Intentaré jugar al golf más adelante, aunque por ahora no veo una manera obvia de hacerlo.

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

Python, 75 bytes

Esto es solo para mostrar. Es el programa que escribí al crear / diseñar este desafío.

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]

Recursivamente crea el árbol. Al [:n]final es un caso especial n==0para dar la lista vacía.

Joe , 8 bytes

Nota: Esta es una respuesta no competitiva. La primera versión de Joe fue lanzada después de esta pregunta.

F:/+,M]R

¿Qué tenemos aquí? F:define una función F que es una cadena de /+,, M]y R. Cuando llama Fn, primero Rnse evalúa, devolviendo el rango de 0 a n, exclusivo. M]ajusta cada elemento a una lista. Entonces la lista se aplica a /+,. x +, y vuelve x + [y]. /Es un pliegue derecho. Por lo tanto, /+,a b c d...vuelve [a, [b, [c, [d...]]].

Invocaciones de ejemplo (el código está sangrado por 3, la salida por 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 - Versión recursiva - 52

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

Versión no recursiva: 66 62 57

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

Salida de muestra (igual para ambas versiones)

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 versión no recursiva puede manejar entradas arbitrariamente 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]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Ambas versiones también aceptan con gracia números negativos

p r[-5] # => []

PHP 5.4 (67 bytes):

Sé que sé.

Está lejos de ser la respuesta más corta.

¡Pero funciona!

Aquí está:

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

Puede probarlo aquí: https://ideone.com/42L35E (ignore el error)

Javascript (57 bytes):

Este es el mismo código exacto , excepto que Javascript es exigente con el retorno y he reducido los nombres de las variables:

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

¿Ver? Mismo código!

ES6 (49 bytes):

Básicamente el mismo código exacto, pero reducido para ES6:

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

Javascript (114 bytes):

Todos los demás estaban haciendo recursivos, así que quería probar una solución iterativa. Sin embargo, tengo muchos casos especiales.

Tengo una lista maestra, y luego repito y agrego nuevas listas con nuevos números.

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 común (95 bytes):

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

Solución recursiva

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

Pruébalo en línea!

05AB1E , 11 bytes

_i¯ëFNI<α)R

Pruébelo en línea o verifique todos los casos de prueba .

Alternativa de 11 bytes:

_i¯ëݨRvy)R

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

05AB1E no tiene bucles que van hacia abajo, por lo que para hacer un bucle en el rango (input, 0]tengo que:

• Cree ese rango primero ( ݨR; cree el rango [0, input], elimine el último elemento, invierta), y luego repítalo ( vy);
• O haga un bucle en el rango [0, input)( F) y tome la diferencia absoluta entre el índice de bucle y la entrada-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)