26

यह चुनौती केवल पायथन रेंज फ़ंक्शन के समान पूर्णांक की सूचियों की सूची को वापस करने के लिए है, सिवाय इसके कि प्रत्येक क्रमिक संख्या सूचियों में गहरी होनी चाहिए।

नियम :

एक कार्यक्रम या एक गैर-अनाम फ़ंक्शन बनाएं
इसे परिणाम को वापस करना चाहिए या प्रिंट करना चाहिए
परिणाम एक सूची (सूची में) या सरणी (सारणी के) में वापस आ जाना चाहिए
यदि पैरामीटर शून्य है, तो एक खाली सूची लौटाएं
यह पूर्णांक पैरामीटर को संभालने में सक्षम होना चाहिए 0 <= n <70।
- (पुनरावर्ती समाधान बहुत तेजी से उड़ा)
फ़ंक्शन केवल एक पैरामीटर के साथ कॉल करने योग्य होना चाहिए।
अन्य व्यवहार अपरिभाषित है।
यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

उदाहरण कॉल:

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

EDIT: isaacg का जवाब अब तक का सबसे छोटा है। अगर किसी को चुनौती देने वाली पोस्ट में मौजूद भाषा में कोई छोटा मिल जाता है तो मैं स्वीकृत उत्तर को अपडेट करूंगा। खेलने के लिए शुक्रिया!

code-golf array-manipulation

— mbomb007
स्रोत

2

यादृच्छिक टिप्पणी: यह हास्यास्पद है कि एक शीर्षक के लिए न्यूनतम चरित्र 15 कैसे है, और मैं "श्रेणी की सूची" का उपयोग नहीं कर सकता, इसलिए मैं इस मौके पर आया।

— mbomb007

यह ज्यादातर लोगों को बिना लिखे हुए अनाम कार्यों को लिखने से रोकने के लिए है। व्यक्तिगत रूप से, मैं इसे पसंद करूंगा यदि यह एक ऐसा फ़ंक्शन था जो एक पैरामीटर लेता है।

— mbomb007

क्या यह दो कार्यों को बनाने की अनुमति है, जहां एक सहायक कार्य है?

— प्रोग्रामफॉक्स

@ProgramFOX हाँ। मुझे लगता है कि आपके फ़ंक्शन के लिए बाहरी कोड ठीक है, क्योंकि अगर कोई import mathउदाहरण के लिए पायथन में चाहता था , तो मुझे नहीं लगता कि यह एक फ़ंक्शन के अंदर हो सकता है।

— mbomb007

@DevonParsons ऐसे बहुत सारे प्रश्न हैं जिनका उदाहरण कार्यक्रम में निहित है, लेकिन ठीक है।

— mbomb007

11

पायथ, 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.

— isaacg
स्रोत

10

एपीएल ( 13 18)

यह मानते हुए ⎕IO=0:

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

स्पष्टीकरण:

×⍵:अगर ⍵सकारात्मक है,
- ,∘⊂∘,: दाहिने ऑपरेंड (यानी x ,∘⊂∘, y = [x, [y]]) के एनक्लोज के लिए बाएं ऑपरेंड में शामिल हों
- /: कम करना
- ⍳⍵: संख्याएँ 0..⍵-1
- ⊃: परिणाम का खुलासा करें
⋄: अन्यथा
- ⍬: खाली सूची वापस करें
- (यह आवश्यक है क्योंकि /विफल रहता है ⍬, और ⍳0खाली सूची देता है।)

परिशिष्ट:

यह फ़ंक्शन नेस्टेड सरणी देता है। हालाँकि, APL के डिफ़ॉल्ट आउटपुट से यह बताना थोड़ा कठिन है। यह रिक्त स्थान द्वारा सरणी आइटम को अलग करता है, इसलिए आप केवल डबल रिक्त स्थान द्वारा नेस्टिंग बता सकते हैं। यहां एक फ़ंक्शन है जो नेस्टेड सरणी लेगा, और एक स्ट्रिंग लौटाएगा, पायथन शैली (यानी [a,[b,[c,...]]]) में नेस्टेड सरणी को स्वरूपित करता है ।

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

— मारीनस
स्रोत

1

मुझे लगता है कि आपको एन्क्लोज़ के बाद एक और ∘ की आवश्यकता है, अन्यथा (कम से कम मेरे दुभाषिया - dyalog14 में) अंतिम तत्व संलग्न नहीं है। जैसे [० [१ [२ ३]]]

— मोरिस ज़ुका

@marinus क्या आप इसे सत्यापित कर सकते हैं?

— mbomb007

मैंने समस्या कथन को एक या दो दिन पहले स्पष्ट कर दिया कि स्पष्ट कार्य एक चर को सौंपा जाना चाहिए। f←जब तक आप इसे उपयोगकर्ता इनपुट स्वीकार करने के लिए संशोधित नहीं करते, आपको अपने कार्यक्रम की शुरुआत में जोड़ना चाहिए ।

— mbomb007

इसके अलावा, आउटपुट यह नहीं दिखाता है कि सूची में कितनी गहराई से एक संख्या स्पष्ट रूप से भिन्न है ... क्या प्रत्येक स्थान एक निहित ब्रैकेट है?

— mbomb007

@MorisZucca मुझे सहमत होना होगा। यहां देखें: ngn.github.io/apl/web/#code=%7B%D7%u2375%3A%2C%u2218%u2282/…

— mbomb007

9

हास्केल, 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

हास्केल में किसी सूची के सभी तत्वों को एक ही प्रकार का होना चाहिए, इसलिए मैं पूर्णांकों को पूर्णांकों की सूची के साथ नहीं मिला सकता हूं और मुझे एक कस्टम सूची प्रकार परिभाषित करना होगा 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]]]]]

— nimi
स्रोत

7

पायथन, 48 बाइट्स

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

विशेष मामले को संभालने के लिए सूची गुणा का उपयोग करना।

— Sp3000
स्रोत

मुझे नहीं लगता कि यह पायथन 2 विशिष्ट है - सभी अजगर में काम करने लगता है।

— isaacg

@ आइसाकग फिक्स्ड। मेरा मूल सबमिशन हालांकि नहीं था

— Sp3000

एक छोटी सी चार-बचत: के *(i<n-1)रूप में किया जा सकता है [:n+~i], क्योंकि यह एक एकल सूची है।

— xnor

6

गणितज्ञ, ३३

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

— alephalpha
स्रोत

यह इतना आसान लग रहा है!

— mbomb007 20

5

सीजेएम, 16 बाइट्स

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

यह एक पूर्ण कार्यक्रम है। यह STDIN के माध्यम से इनपुट लेता है और अंतिम सरणी को STDOUT पर प्रिंट करता है।

अन्य सीजेएम प्रविष्टि के साथ, 0इनपुट प्रिंट होगा ""क्योंकि यह सीजेएम में एक खाली सरणी का प्रतिनिधित्व है।

यह कैसे काम करता है :

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

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

3

जावास्क्रिप्ट (ईएस 6) 40

पुनरावर्ती समाधान, बहुत मजबूत, कोई वार नहीं। 'बहुत अधिक पुनरावृत्ति' के साथ 6500 के पास अपडेट करें

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

Iterative solution (45) मेमोरी उपयोग को छोड़कर कोई सीमा नहीं

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

एफ (1000) आज़माएं: फायरबग कंसोल आपको 190 से अधिक नेस्टेड एरेज़ नहीं दिखाएगा, लेकिन वे वहां हैं

— edc65
स्रोत

3

जावा, 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));}};}

दूसरों की तुलना में बहुत लंबा है, हालांकि आप जावा के साथ ज्यादा बेहतर नहीं कर सकते हैं। यह निर्धारित करने के लिए कि क्या पुनरावृत्ति जारी रखने के लिए एक जांच यह सब है।

— टीएनटी
स्रोत

आपको import java.util.*;इसके लिए स्व-युक्त होना चाहिए (या पूरी तरह से योग्य java.util.Listऔर java.util.Stack, लेकिन यह बहुत लंबा है)। +19 इसे 107 बनाने के लिए, अभी भी जावा जवाब से 7 बेहतर है जिस पर मैं काम कर रहा था: डी

— जियोबिट्स

मुझे लगता है कि आप दो को बचा o!=nसकते हैं : हो सकता है o<n, और आप टर्नरी को स्वैप कर सकते हैं o<n?o++:""।

— Geobits

जावा 8 में, मेरा मानना है कि finalऑन int nको हटाया जा सकता है।

— जस्टिन

2

पायथन 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]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

— तर्क नाइट
स्रोत

खैर, आपने मेरे पायथन समाधान को हराया।

— mbomb007 16

2

सीजेएम, 17 बाइट्स

मुझे पता है कि ऑप्टिमाइज़र को 16 मिल गए हैं, लेकिन यहां सबसे अच्छा मैं कर सकता हूं:

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

यह एक ब्लॉक है, सीजेएम में एक फ़ंक्शन के लिए निकटतम चीज, जो स्टैक पर पूर्णांक लेता है, और वांछित नेस्टेड सरणी को छोड़ देता है।

परीक्षण के लिए इस कार्यक्रम का उपयोग करें , जो इनपुट को स्टैक पर रखता है, फिर फ़ंक्शन को कॉल करता है और स्टैक का निरीक्षण करता है। ध्यान दें कि के लिए 0, ढेर उत्पादन में शामिल होंगे ""- यह है एक खाली सरणी के CJam के देशी प्रतिनिधित्व।

— मार्टिन एंडर
स्रोत

2

रूबी ४६

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

इसे ऑनलाइन टेस्ट करें: http://ideone.com/uYRVTa

— क्रिस्टियन लुपस्कू
स्रोत

2

सी # - 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)};}

सी ++ 87

(विजुअल सी ++ 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 *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;
    }

}

— नाथन कूपर
स्रोत

C ++ संस्करण संकलित नहीं करता है। ideone.com/fmcXYP

— अनमोल सिंह जग्गी

आपको संकलक का उपयोग साथ में करना चाहिए C++।

— अनमोल सिंह जग्गी

@anmolSinghJaggi हाँ, अच्छा विचार है। विजुअल C ++ 2012, जो कि ज्यादातर C ++ 11 कंप्लेंट है।

— नाथन कूपर

पुरानी पोस्ट, लेकिन कुछ छेड़छाड़ के साथ मैंने इसे 86 तक पहुंचा दिया । Array g(params object[]a)=>a;Array f(int y,int x=0)=>y<1?g():y<2?g(x):g(x,f(y-1,x+1));

— दाना

2

अजगर, 15 बाइट्स

?u[HG)_UtQ]tQQY

जो वास्तव में कह रहा है, पायथन में:

Q = eval(input())
if Q:
    print reduce(lambda G,H:[H,G], reverse(range(Q-1)), [Q-1])
else:
    print []

— swstephe
स्रोत

अरे, मुझे खुशी है कि आप पायथ सीख रहे हैं! यदि आप मूल्यांकन किए गए इनपुट को उत्पन्न करना चाहते हैं, तो आप क्यू का उपयोग कर सकते हैं, जो आपके लिए ऐसा करता है। इसके अलावा, Y का प्रीइंस्टीट्यूशन किया गया है []।

— ईसैक

qJ_1के रूप में ही है !Q। और JtQवास्तव में 1 बाइट बर्बाद करता है। ?Y!Qu[HG)_UtQ[tQ

— जकुबे

ठीक है मैं उन बाइट्स ले जाऊँगा।

— स्वस्तिक

@swstephe यदि आप के लिए बदल [tQजाते हैं ]tQ, जो बराबर है, आप के संचालन के आदेश के लिए स्वैप ?, ताकि आप के !Qसाथ बदल सकते हैं Q। इसके परिणामस्वरूप ?u[HG)_UtQ]tQQY- 1 और बाइट बचाई गई।

— isaacg

2

हास्केल , 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यह करेंगी समारोह का उपयोग कर, एक टपल उत्पादन एक पेड़ (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 []]

— ბიმო
स्रोत

1

पर्ल - 44

sub t{$r=[($t)=@_];$r=[$t,$r]while--$t>0;$r}

अनुरोध पर स्पष्टीकरण जोड़ देगा। आप इसे यहाँ आज़मा सकते हैं ।

— hmatt1
स्रोत

मैं सोच रहा था, क्योंकि मैं पर्ल से परिचित नहीं हूं - क्या सबसे गहरी नेस्टेड सरणी में 2 तत्व हैं, एक nilया जो भी समान है? मैं पूछता हूं क्योंकि जिस पृष्ठ पर आप अंतरतम सरणी से जुड़ते हैं, वह दिखता है(3,)

— Devon Parsons

1

@DevonParsons कोड मैंने इसे पठनीय तरीके से प्रिंट करने के लिए जोड़ा है प्रत्येक तत्व के बाद एक अल्पविराम जोड़ता है। Perl undefके समतुल्य है nilया nullइसमें कोई अतिरिक्त तत्व नहीं है। पर्ल चपटे सरणियों तो यह नेस्टेड सरणी संदर्भ बना रहा है।

— hmatt1

1

जावास्क्रिप्ट, 93 बाइट्स

यह आदर्श नहीं है, लेकिन मैं इसे आजमा सकता हूं। मैं कोशिश करूँगा और इसे बाद में गोल्फ दूंगा, हालाँकि अभी के लिए मुझे कोई स्पष्ट रास्ता नहीं दिख रहा है।

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

— vvye
स्रोत

आप पुनरावर्ती समाधान बनाने का भी प्रयास कर सकते हैं, क्योंकि यह कम हो सकता है।

— mbomb007

1

पायथन, 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]

— mbomb007
स्रोत

1

अजगर, ४४

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

फिर से पेड़ बनाता है। [:n]अंत में विशेष मामले के लिए है n==0खाली सूची देने के लिए।

— XNOR
स्रोत

यह इस चुनौती के दौरान था कि मुझे एहसास हुआ कि andऔर orपूर्णांक के बगल में रिक्त स्थान हो सकते हैं, लेकिन elseनहीं कर सकते।

— mbomb007

@ mbomb007 ऐसा इसलिए है क्योंकि इसकी elseशुरुआत होती है e, और जैसी चीजें 1e6मान्य होती हैं, वे वास्तविक संख्या में होती हैं।

— xnor

मुझे पता था कि, लेकिन मुझे नहीं पता था कि ऐसा क्यों था। धन्यवाद।

— mbomb007

1

@ mbomb007 वास्तव में 2.6 या 2.7 के बाद या इससे पहले कि आप अंतरिक्ष खो सकते हैंelse , जैसे x = 1 if y==2else 5काम करता है।

— Sp3000

यह पायथन में काम नहीं करता है 2.7.2 repl.it/eB6 (लेकिन यह 3.4 में काम करता है)

— mbomb007

1

जो , 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]]]]]

— seequ
स्रोत

1

रूबी - पुनरावर्ती संस्करण - 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] # => []

— डेवोन पार्सन्स
स्रोत

बस जिज्ञासु, किस मूल्य पर पुनरावर्ती समाधान विफल हो जाता है (स्मृति / स्टैक अतिप्रवाह के कारण)?

— mbomb007

@ mbomb007 विंडोज 7 x64, 16 जीबी रैम पर, यह 926 पर काम करता है और 927 ( stack level too deep (SystemStackError)) में विफल रहता है

— डेवोन पार्सन्स

0

PHP 5.4 (67 बाइट्स):

मैं जानता हूँ मैं जानता हूँ।

यह सबसे छोटा उत्तर होने से बहुत दूर है।

लेकिन यह काम करता है!

यह रहा:

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

आप इसे यहीं परीक्षण कर सकते हैं: https://ideone.com/42L35E (त्रुटि को अनदेखा करें)

जावास्क्रिप्ट (57 बाइट्स):

यह वही सटीक कोड है जिसे छोड़कर जावास्क्रिप्ट रिटर्न के बारे में उपयुक्त है और मैंने चर नामों को कम कर दिया है:

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

देख? एक ही कोड!

ईएस 6 (49 बाइट्स):

मूल रूप से एक ही सटीक कोड, लेकिन ES6 के लिए कम:

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

— इस्माइल मिगुएल
स्रोत

मैंने कोई अनाम फ़ंक्शन निर्दिष्ट नहीं किया, या यह कहीं टिप्पणी में था। मैं इसे स्पष्ट कर दूंगा।

— mbomb007

@ mbomb007 यह निर्दिष्ट नहीं किया गया था। फ़ंक्शन पर नाम लागू करने के लिए कुछ भी नहीं था । लेकिन मैंने इसे बदल दिया है।

— इस्माईल मिगुएल

इस सवाल के नीचे मेरे द्वारा एक टिप्पणी की गई थी: "यह ज्यादातर लोगों को असम्बद्ध अनाम कार्यों को लिखने से रोकने के लिए है। व्यक्तिगत रूप से, मैं इसे पसंद करूंगा यदि यह एक फ़ंक्शन था जो एक पैरामीटर लेता है।"

— mbomb007

और मैं किया था सवाल बदल जाते हैं। लेकिन यह काम करता है के लिए बहुत मानक codegolf नाम से प्रतिदेय होना जरूरी है कि वे है (उर्फ, और अधिक एक बार और पूरे समारोह फिर से लिखे बिना की तुलना में।) के कारण है कि आप हर किसी को देखने के उपयोग कर रहा है यही कारण है कि कार्यों f=lambda...

— mbomb007

@ mbomb007

But it's pretty standard codegolf for functions that they have to be callable by name (aka, more than once and without typing the entire function again.)

-> इसके बारे में कभी नहीं सुना, और मैं इस वेबसाइट का उपयोग लगभग एक साल के लिए कुछ हद तक करता हूं। इसके अलावा, यह एक अमान्य तर्क है क्योंकि आप फ़ंक्शंस को एक चर में असाइन कर सकते हैं।

— इस्माइल मिगुएल

0

जावास्क्रिप्ट (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}

— ब्रायन जे
स्रोत

0

आम लिस्प (95 बाइट्स):

(defun f(n &optional(i 0))(cond((< i(1- n))(cons i(list(f n(1+ i)))))((> n 0)(list i))(t nil)))

— मार्क रीड
स्रोत

0

जावास्क्रिप्ट, 35 37 बाइट्स

पुनरावर्ती समाधान

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

इसे ऑनलाइन आज़माएं!

— guest271314
स्रोत

0

05AB1E , 11 बाइट्स

_i¯ëFNI<α)R

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

11-बाइट्स वैकल्पिक:

_i¯ëÝ¨Rvy)R

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

05AB1E में कोई लूप नहीं है जो नीचे की ओर जाता है, इसलिए रेंज में लूप के लिए (input, 0]मुझे या तो निम्न करना होगा:

पहले वह रेंज बनाएं ( Ý¨R, रेंज बनाएं [0, input], अंतिम आइटम निकालें, रिवर्स करें), और फिर उस पर लूप करें ( vy);
या [0, input)इसके बजाय सीमा में लूप ( F), और लूप-इंडेक्स और इनपुट -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)

— केविन क्रूज़सेन
स्रोत

सूचियों की सीमा पर घर

पायथ, 13 बाइट्स

एपीएल ( 13 18)

हास्केल, 67 बाइट्स

पायथन, 48 बाइट्स

गणितज्ञ, ३३

सीजेएम, 16 बाइट्स

जावास्क्रिप्ट (ईएस 6) 40

जावा, 88 107 105 104 102 बाइट्स

पायथन 2, 56 बाइट्स

सीजेएम, 17 बाइट्स

रूबी ४६

सी # - 100

सी ++ 87

अजगर, 15 बाइट्स

हास्केल , 65 59 45 41 बाइट्स

व्याख्या

वैकल्पिक, 61 बाइट्स

व्याख्या

पर्ल - 44

जावास्क्रिप्ट, 93 बाइट्स

पायथन, 75 बाइट्स

अजगर, ४४

जो , 8 बाइट्स

रूबी - पुनरावर्ती संस्करण - 52

गैर-पुनरावर्ती संस्करण: 66 62 57

PHP 5.4 (67 बाइट्स):

जावास्क्रिप्ट (57 बाइट्स):

ईएस 6 (49 बाइट्स):

जावास्क्रिप्ट (114 बाइट्स):

आम लिस्प (95 बाइट्स):

जावास्क्रिप्ट, 35 37 बाइट्स

05AB1E , 11 बाइट्स