Tantangan ini hanya mengembalikan daftar bilangan bulat, mirip dengan fungsi rentang Python, kecuali bahwa setiap angka berurutan harus sedalam itu dalam daftar.

Aturan :

• Buat program atau fungsi non-anonim
• Itu harus mengembalikan atau mencetak hasilnya
• Hasilnya harus dikembalikan dalam daftar (daftar) atau array (array)
• Jika parameternya nol, kembalikan daftar kosong
• Ini harus dapat menangani parameter integer 0 <= n <70.
  • (solusi rekursif meledak cukup cepat)
• Fungsi harus dapat dipanggil dengan hanya satu parameter.
• Perilaku lain tidak terdefinisi.
• Ini kode golf, jadi kode terpendek menang.

Contoh Panggilan:

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

Kasus uji:

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: jawaban isaacg adalah yang terpendek sejauh ini. Saya akan memperbarui jawaban yang diterima jika ada yang menemukan jawaban yang lebih pendek dalam bahasa yang ada di posting tantangan. Terima kasih sudah bermain!

Pyth, 13 byte

?hu]+HG_UQYQY

Coba di sini.

                 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)

Dengan asumsi ⎕IO=0:

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

Penjelasan:

• ×⍵:jika ⍵positif,
  • ,∘⊂∘,: gabungkan operan kiri ke lampirkan operan kanan (yaitu x ,∘⊂∘, y = [x, [y]])
  • /: mengurangi
  • ⍳⍵: angka-angka 0..⍵-1
  • ⊃: ungkapkan hasilnya
• ⋄: jika tidak
  • ⍬: kembalikan daftar kosong
  • (ini perlu karena /gagal ⍬, dan ⍳0memberikan daftar kosong.)

Tambahan:

Fungsi ini mengembalikan array bersarang. Namun, agak sulit untuk mengatakan ini dari output default APL. Ini memisahkan item array dengan spasi, jadi Anda hanya bisa mengatakan bersarang dengan spasi ganda. Berikut adalah fungsi yang akan mengambil array bersarang, dan mengembalikan string, memformat array bersarang dalam gaya Python (yaitu [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

Di Haskell semua elemen daftar harus dari jenis yang sama, jadi saya tidak bisa mencampur bilangan bulat dengan daftar bilangan bulat dan saya harus mendefinisikan jenis daftar kustom L. Fungsi helper #secara rekursif membuat daftar yang diperlukan. Fungsi utama pmemeriksa daftar kosong dan memanggil yang #sebaliknya.

Karena tipe data baru tidak dapat dicetak secara default (aturan memperbolehkan hanya untuk mengembalikan daftar), saya menambahkan beberapa kode lagi untuk tujuan demonstrasi:

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

Sekarang:

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

Menggunakan daftar perkalian untuk menangani kasus khusus.

Mathematica, 33

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

CJam, 16 byte

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

Ini adalah program lengkap. Dibutuhkan input melalui STDIN dan mencetak array terakhir ke STDOUT.

Seperti dengan entri CJam lainnya, 0input akan dicetak ""karena itu adalah representasi dari array kosong di CJam.

Cara kerjanya :

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

Cobalah online di sini

JavaScript (ES6) 40

Solusi rekursif, cukup kuat, tidak ada pukulan. Perbarui Gagal di dekat 6500 dengan 'terlalu banyak rekursi'

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

Solusi berulang (45) Tidak ada batasan kecuali penggunaan memori

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

Coba F (1000): Konsol FireBug tidak akan menampilkan lebih dari 190 array bersarang, tetapi mereka ada di sana

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

Cukup lama dibandingkan dengan yang lain, meskipun Anda tidak bisa melakukan jauh lebih baik dengan Java. Pemeriksaan untuk menentukan apakah akan melanjutkan rekursi adalah semua yang diperlukan.

Python 2, 56 byte

Saya menduga ini bisa bermain golf lebih banyak.

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

Tes:

# 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

Saya tahu Pengoptimal telah menemukan 16, tetapi di sini adalah yang terbaik yang dapat saya lakukan:

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

Ini adalah blok, hal yang paling dekat dengan fungsi di CJam, yang mengambil integer di stack, dan meninggalkan array bersarang yang diinginkan.

Gunakan program ini untuk mengujinya , yang menempatkan input pada stack, lalu memanggil fungsi dan memeriksa stack. Perhatikan bahwa untuk 0, output stack akan berisi ""- ini adalah representasi asli CJam dari array kosong.

Ruby 46

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

Uji secara online: http://ideone.com/uYRVTa

C # - 100

Rekursi sederhana. Periksa nol case khusus dan centang dengan satu variabel, turun dengan yang lainnya

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

Yang ini bagus, maksud saya Bizantium, tapi ide dasarnya sama dengan c # one.

Ini implementasi array gaya C, jadi tidak memberi Anda array, ia memberikan pointer int, di mana saya menyimpan int dan pointer lainnya. Seperti ini [0,*] *->[1,#] #-> [2,&] &-> etc:, di mana simbol adalah kode pseudo untuk nilai int pointer dan -> adalah tempat pointer ke dalam memori.

Alangkah baiknya untuk menggunakan implementasi array bergerigi c style yang telah saya buat (batuk), tetapi saya mempertahankannya cukup masuk akal untuk berada di dalam aturan pertanyaan.

Ada cukup banyak operator ternary yang menyalahgunakan di sini, dan juga cukup banyak menyalahgunakan para pemain implisit dari int ke bool.

Contoh: Jika kita membiarkan int *bar = (int*)A(3);, kita dapat melihat:

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

Yang merupakan pointer bicara untuk [0, [1, [2]]].

Oke, baiklah. Sebenarnya tidak harus mengerikan. Berikut ini beberapa kode uji untuk menjalankan kode c ++ ini:

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

Yang sebenarnya mengatakan, dalam 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

Daftar bersarang ini adalah struktur data yang sama dengan yang di-root Tree, kecuali bahwa mereka juga bisa kosong. Oleh karena itu, kita dapat menggunakan daftar mereka - juga disebut Forestuntuk mewakili mereka.

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

Cobalah online!

Penjelasan

Pertama-tama kita perlu mengimplementasikan Treetipe data:

data Tree = Node [Tree] Int

Dari sana hanya rekursi menggunakan dua parameter m(penghitungan) dan nuntuk melacak kapan harus mengakhiri:

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

Alternatif, 61 byte

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

Cobalah online!

Penjelasan

Fungsi ini unfoldForestmengambil daftar nilai awal dan fungsi x -> (y,[x]). Untuk setiap nilai awal xia membuka pohon menggunakan fungsi, menghasilkan tuple di (y,xs)mana yakan menjadi root dan xsdigunakan untuk mengulangi prosedur:

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}

Akan menambahkan penjelasan atas permintaan. Anda bisa mencobanya di sini .

JavaScript, 93 byte

Ini tidak ideal, tetapi saya bisa mencobanya. Saya akan mencoba dan golf ini lebih lanjut nanti, meskipun untuk saat ini saya tidak melihat cara yang jelas untuk melakukannya.

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

Python, 75 byte

Ini hanya untuk pertunjukan. Ini adalah program yang saya tulis ketika membuat / mendesain tantangan ini.

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]

Secara rekursif menciptakan pohon. Yang [:n]pada akhirnya adalah kasus khusus n==0untuk memberikan daftar kosong.

Joe , 8 byte

Catatan: Ini adalah jawaban yang tidak bersaing. Versi pertama Joe dirilis setelah pertanyaan ini.

F:/+,M]R

Apa yang kita punya di sini? F:mendefinisikan fungsi F yang merupakan rantai /+,, M]dan R. Saat Anda menelepon Fn, pertama Rndievaluasi, rentang pengembalian dari 0 hingga n, eksklusif. M]membungkus setiap elemen ke daftar. Kemudian daftar tersebut diterapkan /+,. x +, y kembali x + [y]. /adalah lipatan yang tepat. Jadi, /+,a b c d...kembali [a, [b, [c, [d...]]].

Contoh doa (kode diindentasikan oleh 3, dihasilkan oleh 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 rekursif - 52

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

Versi non-rekursif: 66 62 57

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

Output sampel (sama untuk kedua versi)

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

Versi non-rekursif dapat menangani input besar secara sewenang-wenang.

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

Kedua versi juga dengan anggun menerima angka negatif

p r[-5] # => []

PHP 5.4 (67 byte):

Saya tahu saya tahu.

Itu jauh dari jawaban tersingkat.

Tapi berhasil!

Ini dia:

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

Anda dapat mengujinya di sini: https://ideone.com/42L35E (abaikan kesalahan)

Javascript (57 byte):

Ini adalah kode persis sama kecuali Javascript pilih-pilih tentang pengembalian dan saya telah mengurangi nama variabel:

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

Lihat? Kode yang sama!

ES6 (49 byte):

Pada dasarnya kode persis sama, tetapi dikurangi untuk ES6:

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

Javascript (114 byte):

Semua orang melakukan rekursif, jadi saya ingin mencoba solusi berulang. Saya punya terlalu banyak kasus khusus.

Saya memegang daftar master, dan kemudian loop dan menambahkan daftar baru dengan nomor baru.

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}

Gangguan Umum (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

Solusi rekursif

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

Cobalah online!

05AB1E , 11 byte

_i¯ëFNI<α)R

Cobalah secara online atau verifikasi semua kasus uji .

Alternatif 11-byte:

_i¯ëݨRvy)R

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

05AB1E tidak memiliki loop yang mengarah ke bawah, jadi untuk loop di kisaran (input, 0]saya juga harus:

• Buat rentang itu terlebih dahulu ( ݨR; buat rentang [0, input], hapus item terakhir, balikkan), dan kemudian lewati ( vy);
• Atau loop dalam rentang [0, input)sebagai gantinya ( F), dan ambil perbedaan absolut antara loop-index dan 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)