ความท้าทายนี้เป็นเพียงการส่งคืนรายการของรายการจำนวนเต็มคล้ายกับฟังก์ชันช่วง Python ยกเว้นว่าแต่ละหมายเลขที่ต่อเนื่องจะต้องลึกเข้าไปในรายการ

กฎ :

• สร้างโปรแกรมหรือฟังก์ชั่นที่ไม่ระบุชื่อ
• ควรส่งคืนหรือพิมพ์ผลลัพธ์
• ผลลัพธ์ควรส่งคืนในรายการ (ของรายการ) หรืออาร์เรย์ (ของอาร์เรย์)
• หากพารามิเตอร์เป็นศูนย์ให้ส่งคืนรายการว่าง
• สิ่งนี้ควรจะสามารถจัดการกับพารามิเตอร์จำนวนเต็ม 0 <= n <70
  • (โซลูชันแบบเรียกซ้ำจะระเบิดเร็วขึ้น)
• ฟังก์ชั่นควรจะ callable โดยมีเพียงหนึ่งพารามิเตอร์
• พฤติกรรมอื่น ๆ ไม่ได้กำหนด
• นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดจึงชนะ

ตัวอย่างการโทร:

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

กรณีทดสอบ:

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

แก้ไข: คำตอบของ isaacg นั้นสั้นที่สุด ฉันจะอัปเดตคำตอบที่ได้รับการยอมรับหากใครก็ตามพบคำที่สั้นกว่าในภาษาที่มีอยู่เมื่อโพสต์ความท้าทาย ขอบคุณสำหรับการเล่น!

Pyth, 13 ไบต์

?hu]+HG_UQYQY

ลองที่นี่

                 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)

สมมติว่า⎕IO=0:

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

คำอธิบาย:

• ×⍵:ถ้า⍵เป็นบวก
  • ,∘⊂∘,: เข้าร่วมตัวถูกดำเนินการด้านซ้ายเพื่อล้อมรอบตัวถูกดำเนินการด้านขวา (เช่นx ,∘⊂∘, y = [x, [y]])
  • /: ลด
  • ⍳⍵: ตัวเลข 0..⍵-1
  • ⊃: เปิดเผยผล
• ⋄: มิฉะนั้น
  • ⍬: ส่งคืนรายการว่าง
  • (สิ่งนี้จำเป็นเนื่องจาก/ล้มเหลว⍬และ⍳0ให้รายการที่ว่างเปล่า)

ภาคผนวก:

ฟังก์ชันนี้ส่งคืนอาร์เรย์ที่ซ้อนกัน อย่างไรก็ตามเป็นการยากที่จะบอกสิ่งนี้จากเอาต์พุตเริ่มต้นของ APL มันแยกรายการอาร์เรย์ตามช่องว่างเพื่อให้คุณสามารถบอกได้เพียงการซ้อนโดยช่องว่างสองครั้ง นี่คือฟังก์ชั่นที่จะใช้อาร์เรย์ที่ซ้อนกันและคืนค่าสตริงการจัดรูปแบบอาร์เรย์ที่ซ้อนกันในรูปแบบ Python (เช่น[a,[b,[c,...]]])

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

Haskell, 67 ไบต์

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 Lองค์ประกอบทั้งหมดของรายการจะต้องเป็นชนิดเดียวกันดังนั้นฉันไม่สามารถผสมจำนวนเต็มมีรายชื่อของจำนวนเต็มและฉันต้องกำหนดประเภทรายการที่กำหนดเอง ฟังก์ชั่นตัวช่วย#สร้างรายการที่ต้องการซ้ำ ๆ ซ้ำ ฟังก์ชั่นหลักpจะตรวจสอบรายการว่างเปล่าและการโทรเป็น#อย่างอื่น

เนื่องจากชนิดข้อมูลใหม่ไม่สามารถพิมพ์ได้ตามค่าเริ่มต้น (กฎอนุญาตให้ส่งคืนรายการได้) ฉันจึงเพิ่มรหัสเพิ่มเติมเพื่อวัตถุประสงค์ในการสาธิต:

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

ขณะนี้:

-- 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 ไบต์

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

การใช้การคูณรายการเพื่อจัดการกรณีพิเศษ

Mathematica, 33

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

CJam, 16 ไบต์

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

นี่เป็นโปรแกรมเต็ม ใช้อินพุตผ่าน STDIN และพิมพ์อาร์เรย์สุดท้ายไปยัง STDOUT

เช่นเดียวกับรายการ CJam อื่น ๆ0อินพุตจะพิมพ์""ตามที่เป็นตัวแทนของอาร์เรย์ว่างเปล่าใน CJam

มันทำงานอย่างไร :

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

ลองออนไลน์ได้ที่นี่

JavaScript (ES6) 40

วิธีการแก้ปัญหาแบบเรียกซ้ำมีความแข็งแรงและไม่เกิดการระเบิด การอัปเดตล้มเหลวใกล้กับ 6500 ด้วย 'การเรียกซ้ำมากเกินไป'

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

โซลูชันซ้ำ (45) ไม่มีข้อ จำกัด ยกเว้นการใช้หน่วยความจำ

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

ลอง F (1,000): คอนโซล FireBug จะไม่แสดงอาร์เรย์ซ้อนกันมากกว่า 190 อาร์เรย์ แต่มีอยู่

Java, 88 107 105 104 102 ไบต์

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

ค่อนข้างนานเมื่อเทียบกับคนอื่น ๆ แต่คุณไม่สามารถทำได้ดีกว่ากับ Java การตรวจสอบเพื่อกำหนดว่าจะดำเนินการเรียกซ้ำต่อไปได้หรือไม่

Python 2, 56 ไบต์

ฉันคิดว่ามันน่าจะเล่นกอล์ฟได้มากกว่านี้

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

แบบทดสอบ:

# 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 ไบต์

ฉันรู้ว่าเครื่องมือเพิ่มประสิทธิภาพพบ 16 แต่นี่คือสิ่งที่ดีที่สุดที่ฉันสามารถทำได้:

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

นี่คือบล็อกสิ่งที่ใกล้เคียงที่สุดกับฟังก์ชันใน CJam ซึ่งใช้จำนวนเต็มบนสแต็กและปล่อยอาร์เรย์ที่ซ้อนกันที่ต้องการ

ใช้โปรแกรมนี้เพื่อทดสอบซึ่งวางอินพุตบนสแต็กจากนั้นเรียกใช้ฟังก์ชันและตรวจสอบสแต็ก โปรดทราบว่าสำหรับ0เอาต์พุตสแต็กจะมี""- นี่คือการแทนค่าดั้งเดิมของ CJam ของอาเรย์ที่ว่างเปล่า

ทับทิม 46

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

ทดสอบออนไลน์: http://ideone.com/uYRVTa

C # - 100

เรียกซ้ำง่าย ๆ ตรวจสอบกรณีพิเศษเป็นศูนย์และทำเครื่องหมายกับตัวแปรหนึ่งลงพร้อมกับอีกตัวแปรหนึ่ง

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

อันนี้ดีมากซึ่งฉันหมายถึงไบเซนไทน์ แต่มันเป็นแนวคิดพื้นฐานเดียวกับ c # หนึ่ง

เป็นการใช้งานอาร์เรย์ลักษณะ C ดังนั้นจึงไม่ให้อาร์เรย์กับคุณมันให้ตัวชี้ int ซึ่งฉันได้รับการจัดเก็บทั้ง ints และตัวชี้อื่น ๆ อย่างนี้:[0,*] *->[1,#] #-> [2,&] &-> etcที่สัญลักษณ์เป็นรหัสเทียมสำหรับค่า int ของตัวชี้และ -> เป็นที่ที่ตัวชี้ไปยังหน่วยความจำ

ช่างเป็นอะไรที่ยอดเยี่ยมมากที่ใช้งานง่ายของอาร์เรย์สไตล์หยักที่ฉันได้คิดค้น (ไอ) แต่ฉันก็ยังคงมีความเป็นไปได้ที่จะเป็นไปตามกฎของคำถาม

มีโอเปอร์เรเตอร์ที่ดูถูกเหยียดหยามอยู่มากมายที่นี่และยังมีการเหยียดหยามนักแสดงโดยปริยายจาก int ถึง bool

ตัวอย่าง:ถ้าเราปล่อยint *bar = (int*)A(3);เราจะเห็น:

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

ตัวชี้ตัวใดพูดถึง [0, [1, [2]]]

โอเคสบายดี มันไม่จำเป็นต้องแย่จริงๆ นี่คือรหัสทดสอบบางส่วนสำหรับการเรียกใช้รหัส 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 ไบต์

?u[HG)_UtQ]tQQY

ซึ่งพูดจริงๆใน 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 ไบต์

รายการที่ซ้อนกันเหล่านี้เป็นโครงสร้างข้อมูลเดียวกับรูทTrees ยกเว้นว่าพวกเขาสามารถว่างเปล่าได้ ดังนั้นเราสามารถใช้รายการของพวกเขา - เรียกอีกอย่างว่าForestเพื่อเป็นตัวแทนของพวกเขา

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

ลองออนไลน์!

คำอธิบาย

ก่อนอื่นเราต้องใช้Treeชนิดข้อมูล:

data Tree = Node [Tree] Int

จากตรงนั้นมันเป็นแค่การเรียกซ้ำโดยใช้สองพารามิเตอร์m(นับขึ้น) และnเพื่อติดตามว่าเมื่อใดที่จะยุติ:

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

ทางเลือก 61 ไบต์

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

ลองออนไลน์!

คำอธิบาย

ฟังก์ชั่นใช้เวลารายการของค่าเริ่มต้นและฟังก์ชันunfoldForest x -> (y,[x])สำหรับแต่ละค่าเริ่มต้นxมันจะกางทรีโดยใช้ฟังก์ชั่นโดยสร้าง tuple (y,xs)ซึ่งyจะกลายเป็นรูทและxsใช้เพื่อทำซ้ำโพรซีเดอร์:

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}

จะเพิ่มคำอธิบายตามคำขอ คุณสามารถทดลองใช้งานได้ที่นี่

JavaScript, 93 ไบต์

มันไม่เหมาะ แต่ฉันก็อาจจะลองดู ฉันจะลองเล่นกอล์ฟต่อไปในภายหลัง แต่สำหรับตอนนี้ฉันไม่เห็นวิธีที่ชัดเจน

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

Python ขนาด 75 ไบต์

นี่เป็นเพียงการแสดง เป็นโปรแกรมที่ฉันเขียนเมื่อสร้าง / ออกแบบความท้าทายนี้

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]

สร้างต้นไม้แบบวนซ้ำ [:n]ที่สิ้นสุดคือการกรณีพิเศษn==0เข้ามาให้รายการที่ว่างเปล่า

โจ 8 ไบต์

หมายเหตุ: นี่เป็นคำตอบที่ไม่ใช่การแข่งขัน รุ่นแรกของโจได้รับการปล่อยตัวหลังจากคำถามนี้

F:/+,M]R

เรามีอะไรที่นี่? F:กำหนดฟังก์ชัน F ที่เป็นห่วงโซ่ของ/+,, และM] Rเมื่อคุณโทรFnอันดับแรกRnจะได้รับการประเมินโดยส่งกลับช่วงตั้งแต่ 0 ถึง n โดยเฉพาะ M]ล้อมรอบองค์ประกอบแต่ละรายการ /+,จากนั้นรายการจะถูกนำไปใช้กับ ผลตอบแทนx +, y เป็นพับขวา ดังนั้นผลตอบแทนx + [y]//+,a b c d...[a, [b, [c, [d...]]]

ตัวอย่างการเรียกใช้ (โค้ดเยื้อง 3, ส่งออกด้วย 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 - เวอร์ชันที่เรียกซ้ำ - 52

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

รุ่นที่ไม่ใช่แบบเรียกซ้ำ: 66 62 57

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

เอาต์พุตตัวอย่าง (เหมือนกันสำหรับทั้งสองเวอร์ชัน)

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

เวอร์ชันที่ไม่ใช่แบบเรียกซ้ำสามารถจัดการอินพุตขนาดใหญ่โดยพลการ

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

ทั้งสองเวอร์ชันยังยอมรับตัวเลขที่เป็นลบ

p r[-5] # => []

PHP 5.4 (67 ไบต์):

ฉันรู้ว่าฉันรู้ว่า.

มันไกลจากการเป็นคำตอบที่สั้นที่สุด

แต่มันใช้งานได้!

นี่มันคือ:

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

คุณสามารถทดสอบได้ที่นี่: https://ideone.com/42L35E (ไม่สนใจข้อผิดพลาด)

Javascript (57 ไบต์):

นี่คือรหัสที่แน่นอนเดียวกัน ยกเว้นว่าจาวาสคริปต์จู้จี้จุกจิกเกี่ยวกับการส่งคืนและฉันได้ลดชื่อตัวแปร:

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

ดู? รหัสเดียวกัน!

ES6 (49 ไบต์):

โดยพื้นฐานแล้วรหัสที่แน่นอนเหมือนกัน แต่ลดลงสำหรับ ES6:

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

Javascript (114 ไบต์):

ทุกคนกำลังทำซ้ำดังนั้นฉันจึงอยากลองวิธีแก้ปัญหาแบบวนซ้ำ ฉันมีกรณีพิเศษมากเกินไป

ฉันถือรายการหลักแล้ววนซ้ำและผนวกรายการใหม่ด้วยหมายเลขใหม่

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 ไบต์):

(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 ไบต์

โซลูชันแบบเรียกซ้ำ

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

ลองออนไลน์!

05AB1E , 11 ไบต์

_i¯ëFNI<α)R

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

ทางเลือก 11 ไบต์:

_i¯ëݨRvy)R

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

05AB1E ไม่มีลูปที่ลงด้านล่างดังนั้นในลูปในช่วงที่(input, 0]ฉันต้อง:

• สร้างช่วงนั้นก่อน ( ݨR; สร้างช่วง[0, input]ลบรายการสุดท้ายย้อนกลับ) จากนั้นวนรอบ ( vy);
• หรือวนซ้ำในช่วง[0, input)แทน ( F) และหาผลต่างที่แน่นอนระหว่าง loop-index และ 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)