Diese Herausforderung besteht einfach darin, eine Liste mit ganzen Zahlen zurückzugeben, die der Python-Bereichsfunktion ähnelt, mit der Ausnahme, dass jede aufeinanderfolgende Zahl so tief in Listen sein muss.

Regeln :

• Erstellen Sie ein Programm oder eine nicht anonyme Funktion
• Das Ergebnis sollte zurückgegeben oder gedruckt werden
• Das Ergebnis sollte in einer Liste (von Listen) oder einem Array (von Arrays) zurückgegeben werden.
• Wenn der Parameter Null ist, geben Sie eine leere Liste zurück
• Dies sollte in der Lage sein, einen ganzzahligen Parameter 0 <= n <70 zu behandeln.
  • (rekursive Lösungen explodieren ziemlich schnell)
• Die Funktion sollte nur mit dem einen Parameter aufrufbar sein.
• Anderes Verhalten ist undefiniert.
• Dies ist Codegolf, also gewinnt der kürzeste Code.

Beispiel Anruf:

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

Testfälle:

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: isaacg Die Antwort ist die bisher kürzeste. Ich aktualisiere die akzeptierte Antwort, wenn jemand eine kürzere in einer Sprache findet, die zum Zeitpunkt der Veröffentlichung der Herausforderung vorhanden war. Danke fürs Spielen!

Pyth, 13 Bytes

?hu]+HG_UQYQY

Probieren Sie es hier aus.

                 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)

Vorausgesetzt ⎕IO=0:

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

Erläuterung:

• ×⍵:wenn ⍵positiv ist,
  • ,∘⊂∘,: Verbinde den linken Operanden mit der Einschließung des rechten Operanden (ie x ,∘⊂∘, y = [x, [y]])
  • /: reduzieren
  • ⍳⍵: die Zahlen 0..⍵-1
  • ⊃: das Ergebnis bekannt geben
• ⋄: Andernfalls
  • ⍬: gibt die leere Liste zurück
  • (Dies ist notwendig, da dies /fehlschlägt ⍬und ⍳0die leere Liste anzeigt.)

Nachtrag:

Diese Funktion gibt ein verschachteltes Array zurück. Es ist jedoch etwas schwierig, dies von der Standardausgabe von APL zu unterscheiden. Es trennt Array-Elemente durch Leerzeichen, sodass Sie die Verschachtelung nur durch doppelte Leerzeichen erkennen können. Hier ist eine Funktion, die ein verschachteltes Array verwendet und einen String zurückgibt, der das verschachtelte Array im Python-Stil formatiert (dh [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

In Haskell müssen alle Elemente einer Liste vom selben Typ sein, daher kann ich keine Ganzzahlen mit einer Liste von Ganzzahlen mischen und ich muss einen benutzerdefinierten Listentyp definieren L. Die Hilfsfunktion erstellt #die erforderliche Liste rekursiv. Die Hauptfunktion psucht nach der leeren Liste und ruft #ansonsten auf.

Da neue Datentypen nicht standardmäßig gedruckt werden können (die Regeln erlauben nur das Zurückgeben der Liste), füge ich zu Demonstrationszwecken etwas mehr Code hinzu:

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

Jetzt:

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

Verwendung der Listenmultiplikation zur Behandlung des Sonderfalls.

Mathematica, 33

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

CJam, 16 Bytes

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

Dies ist ein volles Programm. Es nimmt Eingaben über STDIN entgegen und druckt das endgültige Array auf STDOUT.

Wie beim anderen CJam-Eintrag wird die 0Eingabe gedruckt, ""da dies die Darstellung eines leeren Arrays in CJam ist.

Wie es funktioniert :

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

Probieren Sie es hier online aus

JavaScript (ES6) 40

Rekursive Lösung, ziemlich robust, keine Schläge. Update schlägt in der Nähe von 6500 mit "zu viel Rekursion" fehl

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

Iterative Lösung (45) Keine Einschränkungen außer der Speichernutzung

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

Versuchen Sie es mit F (1000): Die FireBug-Konsole zeigt nicht mehr als 190 verschachtelte Arrays an, aber sie sind vorhanden

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

Ziemlich lange im Vergleich zu den anderen, obwohl Sie mit Java nicht viel besser machen können. Es genügt eine Prüfung, um festzustellen, ob die Rekursion fortgesetzt werden soll.

Python 2, 56 Bytes

Ich vermute, das könnte mehr Golf sein.

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 Bytes

Ich weiß, dass Optimizer 16 gefunden hat, aber hier ist das Beste, was ich tun kann:

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

Dies ist ein Block, der einer Funktion in CJam am nächsten kommt, die eine Ganzzahl auf dem Stapel annimmt und das gewünschte verschachtelte Array zurücklässt.

Verwenden Sie dieses Programm, um es zu testen. Dabei wird die Eingabe auf den Stapel gelegt, dann die Funktion aufgerufen und der Stapel überprüft. Beachten Sie, dass für 0die Stapelausgabe Folgendes enthalten wird "": Dies ist CJams native Darstellung eines leeren Arrays.

Rubin 46

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

Testen Sie es online: http://ideone.com/uYRVTa

C # - 100

Einfache Rekursion. Überprüfen Sie den Sonderfall Null und kreuzen Sie mit einer Variablen nach oben und mit der anderen nach unten an

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

Dieser ist großartig, womit ich byzantinisch meine, aber es ist die gleiche Grundidee wie der c # one.

Es ist eine Array-Implementierung im C-Stil, also gibt es kein Array, sondern einen Int-Zeiger, in dem ich sowohl Ints als auch andere Zeiger gespeichert habe. So was:[0,*] *->[1,#] #-> [2,&] &-> etc folgt:, wobei die Symbole Pseudocode für den int-Wert eines Zeigers sind und -> dort, wo er im Speicher verweist.

Was für eine hervorragende, benutzerfreundliche Implementierung von gezackten Arrays im C-Stil, die ich mir ausgedacht habe (cough), aber ich behaupte, es ist plausibel genug, um den Regeln der Frage zu entsprechen.

Es gibt hier eine Menge Missbrauch von ternären Operatoren und auch eine Menge Missbrauch der impliziten Umwandlung von int zu bool.

Beispiel: Wenn wir lassen int *bar = (int*)A(3);, können wir sehen:

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

Welches ist Pointer Talk für [0, [1, [2]]].

Okay gut. Es muss eigentlich nicht das Schreckliche sein. Hier ist ein Testcode zum Ausführen dieses C ++ - Codes:

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

Was in Python wirklich heißt:

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

Diese verschachtelten Listen haben dieselbe Datenstruktur wie die verwurzelten Listen Tree, außer dass sie auch leer sein können. Daher können wir eine Liste von ihnen verwenden - auch a genannt Forest, um sie darzustellen.

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

Probieren Sie es online!

Erläuterung

Zunächst müssen wir den TreeDatentyp implementieren :

data Tree = Node [Tree] Int

Von dort ist es nur eine Rekursion mit zwei Parametern m(Aufwärtszählen) und num zu verfolgen, wann zu beenden ist:

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

Alternative 61 Bytes

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

Probieren Sie es online!

Erläuterung

Die Funktion unfoldForestnimmt eine Liste von Anfangswerten und eine Funktion auf x -> (y,[x]). Für jeden Anfangswert xes entfaltet einen Baum mit der Funktion, ein Tupel produzieren , (y,xs)wo ydie Wurzel werden wird und die xsverwendet werden , um den Vorgang zu wiederholen:

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}

Fügt auf Anfrage eine Erklärung hinzu. Sie können es hier ausprobieren .

JavaScript, 93 Bytes

Das ist nicht ideal, aber ich könnte es genauso gut versuchen. Ich werde versuchen, dies später weiter zu spielen, obwohl ich im Moment keinen offensichtlichen Weg dazu sehe.

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

Python, 75 Bytes

Dies ist nur für die Show. Es ist das Programm, das ich beim Erstellen / Entwerfen dieser Herausforderung geschrieben habe.

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]

Erstellt rekursiv den Baum. Das [:n]am Ende ist auf Sonderfall hin n==0die leere Liste zu geben.

Joe , 8 Bytes

Hinweis: Dies ist eine nicht konkurrierende Antwort. Die erste Version von Joe wurde nach dieser Frage veröffentlicht.

F:/+,M]R

Was haben wir hier? F:definiert eine Funktion F , die eine Kette von ist /+,, M]und R. Wenn Sie anrufen Fn, wird zuerst Rnausgewertet und der Bereich von 0 bis n (exklusiv) zurückgegeben. M]Bricht jedes Element in eine Liste um. Dann wird die Liste angewendet /+,. x +, y kehrt zurück x + [y]. /ist eine rechte Falte. So /+,a b c d...kehrt zurück [a, [b, [c, [d...]]].

Beispielaufrufe (Code wird um 3 eingerückt, Ausgabe um 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 - Rekursive Version - 52

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

Nichtrekursive Version: 66 62 57

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

Beispielausgabe (für beide Versionen gleich)

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

Die nicht-rekursive Version kann beliebig große Eingaben verarbeiten.

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

Beide Versionen akzeptieren auch problemlos negative Zahlen

p r[-5] # => []

PHP 5.4 (67 Bytes):

Ich weiß, ich weiß.

Es ist weit davon entfernt, die kürzeste Antwort zu sein.

Aber es funktioniert!

Hier ist es:

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

Sie können es hier testen: https://ideone.com/42L35E (ignorieren Sie den Fehler)

Javascript (57 Bytes):

Dies ist derselbe genaue Code, außer dass Javascript in Bezug auf die Rückgabe pingelig ist und ich die Variablennamen reduziert habe:

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

Sehen? Gleicher Code!

ES6 (49 Byte):

Grundsätzlich derselbe genaue Code, jedoch reduziert für ES6:

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

Javascript (114 Bytes):

Alle anderen machten rekursiv, also wollte ich eine iterative Lösung ausprobieren. Ich habe jedoch zu viele Sonderfälle.

Ich halte eine Master-Liste, und dann Schleife und Anhängen neuer Listen mit neuen Nummern.

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

Rekursive Lösung

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

Probieren Sie es online!

05AB1E , 11 Bytes

_i¯ëFNI<α)R

Probieren Sie es online oder überprüfen Sie alle Testfälle .

11-Byte-Alternative:

_i¯ëݨRvy)R

Probieren Sie es online oder überprüfen Sie alle Testfälle .

Erläuterung:

05AB1E hat keine Schleifen, die nach unten verlaufen. Um also in dem Bereich zu schleifen, muss (input, 0]ich entweder:

• Erstellen Sie zuerst diesen Bereich ( ݨR; erstellen Sie einen Bereich [0, input], entfernen Sie das letzte Element, kehren Sie ihn um) und durchlaufen Sie ihn dann ( vy).
• Oder durchlaufen Sie [0, input)stattdessen den Bereich ( F) und nehmen Sie die absolute Differenz zwischen dem Schleifenindex und der Eingabe-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)