Bu zorluk sadece art arda gelen her sayının listelerde o kadar derin olması gerekmesi dışında Python aralığı işlevine benzer bir tamsayı listesi listesi döndürmektir.

Kurallar :

• Bir program veya adsız bir işlev oluşturma
• Sonucu iade etmeli veya yazdırmalıdır.
• Sonuç bir listede (listelerde) veya bir dizide (dizilerde) döndürülmelidir
• Parametre sıfırsa, boş bir liste döndür
• Bunun bir tamsayı parametresini 0 <= n <70 kullanması gerekir.
  • (özyinelemeli çözümler oldukça hızlı patlar)
• Fonksiyon sadece bir parametreyle çağrılabilir olmalıdır.
• Diğer davranış tanımsız.
• Bu kod golf, yani en kısa kod kazanır.

Örnek Çağrı:

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

Test Durumları:

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'ın cevabı şimdiye kadarki en kısa. Birisi, görev ilanında var olan bir dilde daha kısa bir cevap bulursa, kabul edilen cevabı güncelleyeceğim. Oynadığınız için teşekkürler!

Pyth, 13 bayt

?hu]+HG_UQYQY

Burada dene.

                 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)

Varsayarak ⎕IO=0:

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

Açıklama:

• ×⍵:eğer ⍵, pozitiftir
  • ,∘⊂∘,: sol işleneni sağ işlenenin çevresine birleştir (örn. x ,∘⊂∘, y = [x, [y]])
  • /: azaltmak
  • ⍳⍵: sayılar 0..⍵-1
  • ⊃: sonucu açıkla
• ⋄: aksi takdirde
  • ⍬: boş listeye geri dön
  • (bu gereklidir, çünkü /başarısız olur ⍬ve ⍳0boş listeyi verir.)

Zeyilname:

Bu işlev iç içe bir dizi döndürür. Ancak, bunu APL'nin varsayılan çıktısından söylemek biraz zor. Dizi öğelerini boşluklarla ayırır, böylece yuvalamayı yalnızca çift boşlukla söyleyebilirsiniz. İşte iç içe diziyi alacak ve iç içe diziyi Python stilinde biçimlendiren (yani [a,[b,[c,...]]]) bir dize döndürecek bir işlev .

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

Haskell, 67 bayt

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

Haskell'de bir listenin tüm unsurları aynı tipte olmalı, bu yüzden tamsayıları tamsayı listesiyle karıştıramam ve özel bir liste tipi tanımlamam gerekiyor L. Yardımcı fonksiyon #, istenen listeyi tekrar tekrar oluşturur. Ana işlev pboş listeyi denetler ve #başka türlü çağırır .

Yeni veri türleri varsayılan olarak yazdırılamadığından (kurallar yalnızca listenin döndürülmesine izin verir), tanıtım amacıyla bazı kodlar eklerim:

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

Şimdi:

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

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

Özel durum ele almak için liste çarpma kullanarak.

Mathematica, 33

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

CJam, 16 bayt

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

Bu tam bir programdır. STDIN üzerinden girdi alır ve son diziyi STDOUT'a yazdırır.

Diğer CJam girişinde olduğu gibi, 0giriş de ""CJam'deki boş bir dizinin temsili olarak basılacaktır.

Nasıl Çalışır :

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

Burada çevrimiçi deneyin

JavaScript (ES6) 40

Özyinelemeli çözüm, oldukça sağlam, darbe yok. Güncelleme 'çok fazla özyineleme' ile 6500 civarında başarısız oldu

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

Yinelemeli çözüm (45) Bellek kullanımı dışında sınırlama yok

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

F (1000) uygulamasını deneyin: FireBug konsolu size 190'dan fazla iç içe diziyi göstermeyecek, ancak oradalar

Java, 88 107 105 104 102 bayt

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

Java ile daha iyisini yapamamanıza rağmen, diğerlerine göre oldukça uzun. Özyinelemeye devam edilip edilmeyeceğini belirleyen bir kontrol yeterlidir.

Python 2, 56 bayt

Bunun daha çok golf oynayabileceğinden şüpheleniyorum.

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

Testler:

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

Optimizer’ın 16 bulduğunu biliyorum, ancak yapabileceğim en iyi şey:

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

Bu, CJam'daki bir işleve en yakın şey, blokta bir tamsayı alan ve istenen iç içe diziden ayrılan bir bloktur.

Girdiyi yığına koyan ve ardından işlevi çağıran ve yığını denetleyen sınamak için bu programı kullanın . Bunun için 0, yığın çıktısının içereceğini unutmayın ""- bu , CJam'in boş bir dizinin yerel gösterimidir.

Yakut 46

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

Çevrimiçi sınayın: http://ideone.com/uYRVTa

C # - 100

Basit özyineleme. Sıfır özel durumu kontrol edin ve bir değişken ile diğerini işaretleyin

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

Bu, bizans kastettiğim harika ama c # one ile aynı temel fikir.

Bu bir C tarzı dizi uygulamasıdır, bu yüzden size bir dizi vermez, hem iç hem de diğer işaretçileri sakladığım bir int işaretçisi verir. Bunun gibi: [0,*] *->[1,#] #-> [2,&] &-> etcsembollerin bir göstergenin int değeri için sahte kod olduğu ve -> bellekte işaret ettiği yer.

C tarzı tırtıklı dizilerin uygulanmasında kullanımı kolay, mükemmel bir kolaylık (öksürük), ama sorunun kuralları dahilinde olacak kadar makul olduğunu düşünüyorum.

Burada oldukça fazla suiistimal yapan operatör var ve aynı zamanda int'den bool'a kadar yapılan dolaylı aldatmaca da oldukça fazla.

Örnek: İzin int *bar = (int*)A(3);verirsek şunları görebiliriz:

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

İşaretçi konuşması olan [0, [1, [2]]] için.

Tamam iyi. Aslında korkunç olmak zorunda değil. İşte bu c ++ kodunu çalıştırmak için bazı test kodu:

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 bayt

?u[HG)_UtQ]tQQY

Gerçekten, Python'da:

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 bayt

Bu iç içe listeler, Treeboş olmaları dışında, köklü s'lerle aynı veri yapısına sahiptir . Dolayısıyla, bir listesini kullanabiliriz - Forestonları temsil etmek için aynı zamanda .

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

Çevrimiçi deneyin!

açıklama

Öncelikle, Treeveri türünü uygulamamız gerekiyor :

data Tree = Node [Tree] Int

Oradan sadece iki parametre kullanarak tekrarlama m(sayma) ve nne zaman sonlandırılacağı takip edilir:

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

Alternatif, 61 bayt

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

Çevrimiçi deneyin!

açıklama

İşlev unfoldForest, başlangıç ​​değerlerinin bir listesini ve bir işlevi alır x -> (y,[x]). Her bir başlangıç değeri için xbu izlerken bir demet üreten bir fonksiyon kullanılarak, ağaç kök olur ve prosedür tekrar kullanılır:(y,xs)yxs

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}

İstek üzerine açıklama ekleyecektir. Burada deneyebilirsiniz .

JavaScript, 93 bayt

Bu ideal değil, ama bir deneyebilirim. Bunu daha sonra golf oynayıp deneyeceğim, ancak şimdilik bariz bir yol göremiyorum.

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

Python, 75 bayt

Bu sadece şov için. Bu zorluğu yaratırken / tasarlarken yazdığım program.

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]

Özyinelemeli ağacı oluşturur. [:n]Sonunda özel durum etmektir n==0boş liste vermeleri için.

Joe , 8 bayt

Not: Bu yarışmacı olmayan bir cevaptır. Joe'nun ilk versiyonu bu sorudan sonra piyasaya sürüldü.

F:/+,M]R

Burada neyimiz var? F:bir zincir olan bir fonksiyonu F tanımlar /+,, M]ve R. Aradığınızda Fn, önce Rndeğerlendirilir, 0'dan n'ye, özel değere geri döndürülür. M]her öğeyi bir listeye kaydırır. Sonra liste uygulanır /+,. x +, y döner x + [y]. /sağa katlanır. Böylece /+,a b c d...döner [a, [b, [c, [d...]]].

Örnek başlatmalar (kod 3 ile girintili, çıktı 0 ile belirtilmiştir):

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

Yakut - Özyinelemeli versiyonu - 52

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

Özyinelemeli olmayan sürüm: 66 62 57

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

Örnek çıktı (her iki sürüm için aynı)

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

Özyinelemeli olmayan sürüm keyfi büyük girdi girişi yapabilir.

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

Her iki sürüm de, negatif sayıları incelikle kabul eder

p r[-5] # => []

PHP 5.4 (67 bayt):

Biliyorum biliyorum.

En kısa cevap olmaktan uzak.

Ama işe yarıyor!

İşte burada:

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

Tam burada test edebilirsiniz: https://ideone.com/42L35E (hatayı yoksayın)

Javascript (57 bayt):

Bu aynı kesin kod JavaScript dönüşü konusunda seçici ve ben değişken adları düşürdük dışında:

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

Görmek? Aynı kod!

ES6 (49 bayt):

Temelde aynı kod, ancak ES6 için azaltılmış:

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

Javascript (114 bayt):

Diğer herkes özyinelemeli yapıyordu, bu yüzden yinelemeli bir çözüm denemek istedim. Yine de çok özel davalarım var.

Bir ana liste tuttum, sonra da yeni numaralarla yeni listeler oluşturup ekledik.

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}

Ortak Lisp (95 bayt):

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

Özyinelemeli çözüm

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

Çevrimiçi deneyin!

05AB1E , 11 bayt

_i¯ëFNI<α)R

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

11 bayt alternatif:

_i¯ëݨRvy)R

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

05AB1E aşağıya doğru dönen bir döngüye sahip değil, yani aralıktaki döngüye (input, 0]girmek için:

• Önce bu aralığı yaratın ( ݨR; aralık yaratın [0, input], son öğeyi kaldırın, geriye doğru) ve sonra üzerine gelin ( vy);
• Veya [0, input)bunun yerine aralıkta döngü ( F) yapın ve döngü indeksi ile giriş-1 ( NI<α) arasındaki mutlak farkı alın .

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