परिभाषा

a (1) = 1
a (2) = 1
a (n) = a (na (n-1)) + a (na (n-2)) n> 2 के लिए जहाँ n एक पूर्णांक है

कार्य

सकारात्मक पूर्णांक को देखते हुए n, उत्पन्न करें a(n)।

परीक्षण के मामलों

संदर्भ

ओब्लीगेटरी OEIS A005185

code-golf sequence arithmetic

— लीक नन
स्रोत

रेटिना , 84 83 79 74 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

.+
$*;1¶1¶
+`;(?=(1)+¶(1)+)(?=(?<-1>(1+)¶)+)(?=(?<-2>(1+)¶)+)
$3$4¶
G3=`
1

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

मुझे यह कुछ और बाद में गोल्फ करना होगा।

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

9

हास्केल, 35 33 बाइट्स

a n|n<3=1|b<-a.(-)n=b(b 1)+b(b 2)

एक कार्य को परिभाषित करता है a।

— एंडर्स कसीर्ग
स्रोत

2

बाँध के साथ अच्छी चाल! क्या (b.b)1+(b.b)2राशि से कुछ छोटा नहीं होगा ?

— xnor

क्यों हां, धन्यवाद @xnor

— एंडर्स कासोर्ग

8

जूलिया, 29 बाइट्स

!n=n<3||!(n-!~-n)+!(n-!~-~-n)

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

यह काम किस प्रकार करता है

हम !अपने उद्देश्यों के लिए एकात्मक ऑपरेटर को फिर से परिभाषित करते हैं।

यदि n है 1 या 2 , n<3रिटर्न सच और यह हमारी वापसी मान है।

अगर एन से बड़ा 2 , n<3रिटर्न झूठी और || शाखा निष्पादित हो जाती है। यह परिभाषा का एक सीधा कार्यान्वयन है, जहां ~-nपैदावार n - 1 और ~-~-nपैदावार n - 2 है ।

— डेनिस
स्रोत

7

सेसोस, 54 बाइट्स

0000000: eefb5b 04f83a a75dc2 36f8d7 cf6dd0 af7b3b 3ef8d7  ..[..:.].6...m..{;>..
0000015: cfed12 f661f0 ae9d83 ee63e6 065df7 ce6183 af7383  ....a.....c..]..a..s.
000002a: 76ef3c 3f6383 7eff9c b9e37f                       v.<?c.~.....

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

disassembled

या ब्रेनफक नोटेशन में:

+>+>>>>>>,-[[->+<]>-<<++[<<<<[->>>+<<<]>>>>[-<<<+<+>>>>]<<<[->>>+<<<]>>>>++[<<<<<[<
[->>+<<]>[-<+>]<-]>>[-<+<+>>]>[<<[->+<]>>[-<<+>>]>]>>>-]<<[-<<<+>>>]>-]>>]<<<<<<<.

— एंडर्स कसीर्ग
स्रोत

6

सी, 43 42 बाइट्स

@ डेनिस को 1 बाइट धन्यवाद दिया

हर उत्तर एक ही है, मुझे कुछ अलग करना चाहिए!

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

a(n){return n<3?:a(n-a(n-2))+a(n---a(n));}

स्पष्टीकरण: यह मूल रूप से है, a(n-a(n-2))+a(n-a(n-1))लेकिन झूलते ^{अपरिभाषित} व्यवहार (मेरे फोन (जीसीसी) और आइडोन पर काम करता है) के साथ।

— betseg
स्रोत

4

1. आपको संकलक का भी उल्लेख करना चाहिए; आपका "स्वैग" अपरिभाषित व्यवहार है। 2. जीसीसी के साथ, आपको 1बीच ?और की जरूरत नहीं है :।

— डेनिस

@ डेनिस दिलचस्प रूप से, वही फॉर्मूलेशन मेरे पुनरावृत्त PowerShell उत्तर में काम करता है ...$b+=$b[$_-$b[$_-2]]+$b[$_---$b[$_]]

— AdmBorkBork

@TimmyD कुछ संकलक n-- से पहले a (n) संकलित कर सकता है, और उस पर कोई standart (या परिभाषित) व्यवहार नहीं है। इस प्रकार, अपरिभाषित व्यवहार।

— betseg

@ लेटसेप हां, मैं सहमत हूं। केवल यह इंगित करते हुए कि यह आवश्यक नहीं है कि सी के लिए अद्वितीय हो

— AdmBorkBork

@TimmyD ओह मुझे गलत समझा गया है। मैं बस उस फ़ंक्शन को बदलना चाहता था जो हर कोई उपयोग करता है, इसलिए मेरा अलग और स्वैग होगा: D

— betseg

5

गणितज्ञ, 36 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग और मैथमेटिका के $CharacterEncodingसेट WindowsANSI(विंडोज पर डिफ़ॉल्ट; अन्य सेटिंग्स के रूप में अच्छी तरह से काम कर सकती है, लेकिन कुछ UTF-8निश्चित रूप से ऐसा नहीं करती)।

±1=±2=1
±n_:=±(n-±(n-1))+±(n-±(n-2))

±एक एकीकृत ऑपरेटर के रूप में परिभाषित करता है ।

मैंने नकल से छुटकारा पाने की कोशिश की, लेकिन एक ही बाइट गिनती के साथ समाप्त हो गई:

±1=±2=1
±n_:=Tr[±(n-±(n-#))&/@{1,2}]

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

यदि आप रेटिना में करते हैं तो मैं आपको एक +200 इनाम दे सकता हूं

— लीक नून

@LeakyNun ठीक है? :)

— मार्टिन एंडर

दो दिन पश्चात।

— लीकेई नन

@ LeakyNun जल्द ही आप कोई रिपीट नहीं होने वाले हैं यदि आप इतनी आसानी से बाउंस दे देते हैं।

— mbomb007

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— लेगियनममाल

4

जेली , 15 14 बाइट्स

2Rạ⁸ß€$⁺Sµ1>?2

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (कुछ सेकंड लगते हैं)।

यह काम किस प्रकार करता है

2Rạ⁸ß€$⁺Sµ1>?2  Main link. Argument: n (integer)

2R              Yield [1, 2].
      $         Combine the previous three links into a monadic chain.
   ⁸                Yield n.
  ạ                 Take the absolute difference of the return value and n.
    ß€              Recursively call the main link on each result.
       ⁺            Duplicate the chain.
                    The first copy maps [1, 2] to [a(n - 1), a(n - 2)].
                    The second copy maps [a(n - 1), a(n - 2)] to
                    [a(n - a(n - 1)), a(n - a(n - 2))].
        S           Take the sum.
         µ          Combine all links to the left into a chain.
            ?       If...
           > 2          n is greater than 2, call the chain.
          1         Else, return 1.

— डेनिस
स्रोत

यदि आप सेसोस में करते हैं तो मैं आपको एक +400 इनाम दे सकता हूं।

— लीक नन

@LeakyNun एक सेसोस उत्तर लगता है। यह आपकी टिप्पणी के एक दिन बाद सामने आया।

— यति

4

जेली , 14 12 11 बाइट्स

ịḣ2S;
1Ç⁸¡2ị

यह एक पुनरावृत्त दृष्टिकोण है।

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

यह काम किस प्रकार करता है

1Ç¡2ị   Main link. Argument: n

1       Set the return value to 1.
 Ç¡     Call the helper link n times, updating the return value after each call.
   2ị   Extract the second element of the resulting array.


ịḣ2S;   Helper link. Argument: A (array)

ị       At-index; retrieve the elements of A at the values of A.
 ḣ2     Head 2; extract the first two results.
    S   Take the sum of the result.
     ;  Prepend the sum to A.

— डेनिस
स्रोत

3

पायथन, 45 40 बाइट्स

a=lambda n:n<3or a(n-a(n-1))+a(n-a(n-2))

चुनौती की सरल भोली व्याख्या।

सहेजे गए 5 बाइट्स @LeakyNun को धन्यवाद!

— तांबा
स्रोत

3

हास्केल, 39 37 बाइट्स

h n|n<3=1|n>2=h(n-h(n-1))+h(n-h(n-2))

बिल्कुल गार्ड की तरह चुनौती में वर्णित है

— KarlKastor
स्रोत

क्षमा करें, मैंने अपना (समान) हैस्केल समाधान पोस्ट करने से पहले आपका समाधान नहीं देखा। हालाँकि बाइट की संख्या 38 नहीं है क्योंकि नई-लाइन को ध्यान में रखा जाना चाहिए?

— लैकोनी

और गार्ड हो गया है n<3के लिए h 2 होने के लिए 1।

— लकोनी

@ लिकोनी यह एक मल्टीलाइन ("" ") स्ट्रिंग के साथ पायथन लेन सुविधा के अनुसार 37 है, जब तक कि आप दो बाइट्स के रूप में न्यूलाइन की गिनती नहीं करते हैं। हाँ, मैंने दूसरी चीज़ पर ध्यान दिया है जो अब तय हो गई है।

— KarlKastor

टीआईएल नोटपैड ++ न्यूलाइन को दो वर्णों के रूप में गिनाता है।

— लकोनी

@ लैकोनी को अब नई सीमा से छुटकारा मिल गया है जो निर्विवाद रूप से 37 बाइट्स है।

— कार्लक्स्टोर

3

आर, 50 बाइट्स

a=function(n)ifelse(n<3,1,a(n-a(n-1))+a(n-a(n-2)))

उपयोग:

> a(1)
  1
> a(20)
  12

— DSkoog
स्रोत

3

CJam, 19 18 बाइट्स

XXri{_($2$$+}*]-3=

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

पुनरावृत्त दृष्टिकोण का उपयोग करता है।

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

3

सी #, 51 44 बाइट्स

int a(int n)=>n<3?1:a(n-a(n-1))+a(n-a(n-2));

~~मुझे आश्चर्य है कि अगर यह अनाम~~ धन्यवाद Pinkfloydx33 ~~बनाकर इसे छोटा किया जा सकता है~~ !

— downrep_nation
स्रोत

1

c # 6 अभिव्यक्ति शारीरिक क्रियाint a(int n)=>n<3?1:a(n-a(n-a))+a(n-a(n-2));

— गुलाबीफ्लॉक्स

लगता है कि मैं अपने फोन पर टाइप करते समय टाइप कर रहा हूं। -a-1

— Parens

मैंने इसे नोटिस नहीं किया था, बीमार इसे ठीक करें rq

— downrep_nation

3

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स 34 बाइट्स

ES6 में एक पुनरावर्ती समाधान। किसी भी गोल्फ युक्तियाँ बहुत सराहना की।

a=n=>n>2?a(n-a(n-1))+a(n-a(n-2)):1

आगे भी छोटा करने के लिए / u / ismillo को धन्यवाद ।

— BugHunterUK
स्रोत

2

गोल्फस्क्रिप्ट, 29 बाइट्स

~[1 1]{..0=(=\..1=(=@+\+}@*2=

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

— लीक नन
स्रोत

2

05AB1E, 29 बाइट्स

एक पुनरावृत्त समाधान।

XˆXˆÍL>v¯¤ys-è¯y¯yÍè-è+ˆ}¯¹<è

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

— Emigna
स्रोत

2

एपीएल, 20 बाइट्स

{⍵≤2:1⋄+/∇¨⍵-∇¨⍵-⍳2}

स्पष्टीकरण:

{⍵≤2:1⋄+/∇¨⍵-∇¨⍵-⍳2}
 ⍵≤2:1               If argument is 2 or less, return 1
      ⋄              Otherwise:
               ⍵-⍳2  Subtract [1, 2] from the argument
             ∇¨      Recursive call on both
           ⍵-        Subtract both results from the argument     
         ∇¨          Recursive call on both again
       +/            Sum

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

2

VBA Excel 87 बाइट्स

गैर-पुनरावर्ती, क्योंकि मैं चाहता हूं कि यह n = 100000 के लिए काम करे, कहो:

Function A(N):ReDim B(N):For i=3 To N:B(i)=B(i-B(i-1)-1)+B(i-B(i-2)-1)+1:Next:A=B(N)+1

... और "फ्री" के लिए स्टेटमेंट returnपाने के लिए लाइन के अंत में (बाइट # 87) दबाएँ End Function। ध्यान दें कि n मान 1 और 2 के लिए प्रारंभ करने से बचने के लिए बी मानों को ऑफसेट किया जाता है।

स्प्रेडशीट में सामान्य रूप से शामिल करें, जैसे =A(100000)पाने के लिए48157

पुनरावर्ती संस्करण, 61 बाइट्स ,

Function Y(N):If N<3 Then Y=1 Else Y=Y(N-Y(N-1))+Y(N-Y(N-2))

n> 30 के लिए अनुचित रूप से धीमी गति से शुरू होता है, और n> 40 के लिए बिल्कुल भी काम करने के लिए नहीं कहा जा सकता है।

— Joffan
स्रोत

हमें प्रदर्शन की परवाह नहीं है। हमें कोड की लंबाई की परवाह है। आपको अपने छोटे से हल को अपने उत्तर के शीर्ष पर ले जाना चाहिए।

— mbomb007

1

@ mbomb007 चूंकि मैं गोल्फ जीतने के आस-पास हूं, मैं एक काम करने वाले कार्यक्रम का चुनाव करता हूं। जब तक मैं चिंतित हूं, तब तक सिंगल बाइट पूर्णांकों को संभालने में सक्षम नहीं है, जब कोई समाधान होता है जो इतनी आसानी से कर सकता है।

— जोफान

2

रूबी, 36 बाइट्स

एक सीधा कार्यान्वयन। किसी भी गोल्फ सुझाव का स्वागत है।

a=->n{n<3?1:a[n-a[n-1]]+a[n-a[n-2]]}

— Sherlock9
स्रोत

अफाक, आप एक = से छुटकारा पा सकते हैं। यदि आप इसे यहाँ पोस्ट करते हैं, तो यह तब होता है जब आपका कोड -> से शुरू होता है। यह एक अनाम फ़ंक्शन के रूप में गिना जाता है।

— सिम्स

@Seims दुर्भाग्य से, जैसा कि फ़ंक्शन स्वयं को कॉल करता है a[n-1]और इस तरह, फ़ंक्शन को नाम देने की आवश्यकता होती है।

— शर्लक 9

2

जावा 7, 68 61 51 बाइट्स

17 को लीक नन की बदौलत बचाया गया।

int a(int n){return n<3?1:a(n-a(n-1))+a(n-a(n-2));}

— जस्टिन
स्रोत

PPCG में आपका स्वागत है!

— AdmBorkBork

PPCG में आपका स्वागत है! आप जावा में गोल्फिंग के लिए टिप्स पसंद कर सकते हैं । एक वैकल्पिक रूप होगा:, int a(int n){return n<3?1:a(n-a(n-2))+a(n---a(n));}लेकिन दुर्भाग्य से यह बाइट्स की उतनी ही मात्रा का उपयोग करता है जितना कि आपके पास पहले से मौजूद उत्तर है .. साथ ही, मैं यह निर्दिष्ट करूंगा कि आपका उत्तर जावा 7 में है, क्योंकि जावा 8 का उत्तर छोटा होगा: n->return n<3?1:a(n-a(n-1))+a(n-a(n-2))( 39 बाइट्स ) ।

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

स्वागत करने वाले लोगों के लिए धन्यवाद, और Java8 पर टिप के लिए धन्यवाद - मुझे नहीं पता था कि लंबोदा को इस तरह की अनुमति दी गई थी - हालांकि उन्हें पायथन में इस तरह की अनुमति है, इसलिए मुझे लगता है कि मैंने इसके बारे में कभी नहीं सोचा था। क्या लैम्ब्डा को अर्ध-बृहदान्त्र की आवश्यकता है?

— जस्टिन

@JustinTervay मैं जावा 8 का बहुत अधिक उपयोग नहीं करता, लेकिन मैंने जो सुना है, उसके बारे में मेरे अपने एक जावा उत्तर में @DavidConrad और @ CAD97 की टिप्पणी के अनुसार, सेमी-कोलोन को सिंगल-लाइन एक्सप्रेशन पर नहीं गिना जाता है। ।

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

2

ओएसिस , ९ asis ५ बाइट्स (गैर-प्रतिस्पर्धात्मक)

गैर-प्रतिस्पर्धात्मक , चूंकि भाषा चुनौती का सामना करती है। 4 बाइट बचाने के लिए केनी लाउ को धन्यवाद । कोड:

ece+V

विस्तारित रूप (के Vलिए छोटा है 11):

a(n) = ece+
a(0) = 1
a(1) = 1

कोड:

e        # Stack is empty, so a(n - 1) is used, and it calculates a(n - a(n - 1))
 c       # Calculate a(n - 2)
  e      # Calculate a(n - a(n - 2))
   +     # Add up

इसे ऑनलाइन आज़माएं! । 0.1 सेकंड में n = 1000 की गणना करता है।

— अदनान
स्रोत

1

PowerShell v2 +, 85 79 69 बाइट्स

param($n)$b=1,1;2..$n|%{$b+=$b[$_-$b[$_-1]]+$b[$_-$b[$_-2]]};$b[$n-1]

इनपुट लेता है $n, $bएक सरणी सेट करता है @(1, 1), फिर से एक लूप में प्रवेश करता है 2 .. $n। प्रत्येक पुनरावृत्ति हम $bएक सरल +=और अनुक्रम की परिभाषा के साथ अनुक्रम में नवीनतम गणना से निपटते हैं। हम तब से उपयुक्त संख्या का उत्पादन करते हैं $b( -1क्योंकि PowerShell में सरणियाँ शून्य-अनुक्रमित हैं)। यह काम करता $nहै 1या नहीं, 2क्योंकि यह दोनों मूल्य $bशुरू से ही कम सूचकांकों में पहले से आबाद हैं , इसलिए भले ही कबाड़ पर लूप टिक जाए, लेकिन इसे वैसे भी नजरअंदाज कर दिया जाता है।

पुनरावर्ती समाधान 78 76 बाइट्स

$a={param($k)if($k-lt3){1}else{(&$a($k-(&$a($k-1))))+(&$a($k-(&$a($k-2))))}}

पहली बार मैंने जवाब के रूप में एक लंबोदर के बराबर का उपयोग किया है, जैसा कि आमतौर पर एक पुनरावृत्त समाधान कम होता है (जैसा कि आप सभी नेस्टेड पेरेन्स से देख सकते हैं)। लेकिन, इस मामले में, नेस्टेड पेरेस को नेस्टेड सरणी कॉल के साथ पुनरावृत्त समाधान में लगभग डुप्लिकेट किया गया है, इसलिए पुनरावर्ती समाधान कम है। नहींं, पुनरावृत्ति समाधान वास्तव में छोटा है (ऊपर देखें)।

इसे निष्पादन-ऑपरेटर के माध्यम से कॉल करें, जैसे &$a 20। बस सीधे-सीधे पुनरावर्ती कॉल।

— AdmBorkBork
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

n=>[...Array(n+1)].reduce((p,_,i,a)=>a[i]=i<3||a[i-p]+a[i-a[i-2]])

गति के लिए गैर-पुनरावर्ती संस्करण; पुनरावर्ती संस्करण शायद कम है, लेकिन मैं इसे किसी और को लिखने के लिए छोड़ दूँगा। मैं हमेशा इसे पसंद करता हूं जब मुझे उपयोग करना होता है reduce। नोट: 1 बाइट वापसी के द्वारा बचाई गई true(जो जाती है1 एक पूर्णांक संदर्भ में इस्तेमाल किया जाता है) के लिए a(1)औरa(2) ।

— नील
स्रोत

1

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

L|<b3smy-bytdtBb

L                  def y(b):
 |<b3                b < 3 or …
      m      tBb       map for d in [b - 1, b]:
       y-bytd            y(b - y(d - 1))
     s                 sum

एक फ़ंक्शन को परिभाषित करता है y।

इसे ऑनलाइन आज़माएं ( yMS20पहले 20 मानों को प्रिंट करने के लिए जोड़ा गया)

— एंडर्स कसीर्ग
स्रोत

1

फोर्थ, 76 बाइट्स

मैं अंत में यह काम कर गया!

: Q recursive dup dup 3 < if - 1+ else 2dup 2 - Q - Q -rot 1- Q - Q + then ;

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

स्पष्टीकरण:

: Q recursive                           \ Define a recursive function Q
    dup dup 3 <                         \ I moved a dup here to golf 2 bytes
    if                                  \ If n < 3, return 1
        - 1                             \ Golf: n-n is zero, add one. Same as 2drop 1+
    else
        2dup 2 - Q - Q                  \ Copy n until 4 on stack, find Q(n-Q(n-2))
        -rot                            \ Move the result below 2 copies of n
        1- Q - Q +                      \ Find Q(n-Q(n-2)), then add to previous ^
    then ;

इसे ऑनलाइन आज़माएं (ऊपर से थोड़ा अन-गोल्फ)

दुर्भाग्य से, पारस्परिक पुनरावृत्ति गोल्फ के लिए उपयोग करने के लिए थोड़ा बहुत चिंतित है।

— mbomb007
स्रोत

1

मेपल, 43 41 बाइट्स

a:=n->`if`(n>2,a(n-a(n-1))+a(n-a(n-2)),1)

उपयोग:

> a(1);
  1
> a(20);
  12

यह समस्या निश्चित रूप से संस्मरण के लिए एक अच्छा उम्मीदवार है। विकल्प कैश का उपयोग करके , रन समय में काफी कटौती की जाती है:

aC := proc(n) 
      option cache; 
      ifelse( n > 2, aC( n - aC(n-1) ) + aC( n - aC(n-2) ), 1 ); 
end proc:

इसका उपयोग करके देखा जा सकता है:

CodeTools:-Usage( aC(50) );

— DSkoog
स्रोत

0

जे, 29 28 बाइट्स

1:`(+&$:/@:-$:@-&1 2)@.(2&<)

पुनरावर्ती परिभाषा का उपयोग करता है।

प्रयोग

कई इनपुट / आउटपुट को फॉर्मेट करने के लिए अतिरिक्त कमांड का उपयोग किया जाता है।

   f =: 1:`(+&$:/@:-$:@-&1 2)@.(2&<)
   (,:f"0) >: i. 20
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
1 1 2 3 3 4 5 5 6  6  6  8  8  8 10  9 10 11 11 12

व्याख्या

1:`(+&$:/@:-$:@-&1 2)@.(2&<)  Input: n
                        2&<   If n < 2
1:                              Return 1
                              Else
               -&1 2            Subtract [1, 2] from n to get [n-1, n-2]
            $:@                 Call recursively on n-1 and n-2
           -                    Subtract each of the results from n
        /@:                     Reduce using
      $:                          A recursive call on each
    +&                            Then summation
                                Return that value as the result

— मील की दूरी पर
स्रोत

0

डीसी, 62 बाइट्स

?si2sa1dd2:a:a[la1+dsadd1-;a-;alad2-;a-;a+r:ali;a0=A]dsAxli;af

यह समाधान सरणियों और पुनरावृत्ति का उपयोग करता है।

?si          # Take input from stdin and store it in register `i'
2sa          # Initialise register `a' with 2, since we'll be putting in the first
             #   two values in the sequence
1dd2         # Stack contents, top-down: 2 1 1 1
:a           # Pop index, then pop value: Store 1 in a[2]
:a           # Ditto:                     Store 1 in a[1]
[            # Open macro definition
 la 1+ dsa   # Simple counter mechanism: Increment a and keep a copy on stack

# The STACK-TRACKER(tm): Top of stack will be at top of each column, under the
#   dashed line. Read commands from left to right, wrapping around to next line.
#   This will be iteration number n.
  dd   1-    ;a       -          ;a            la            d          
#-----------------------------------------------------------------------
# n    n-1   a[n-1]   n-a[n-1]   a[n-a[n-1]]   n             n          
# n    n     n        n          n             a[n-a[n-1]]   n          
# n    n     n                                 n             a[n-a[n-1]]
#                                                            n          
#                                                                       

  2-            ;a            -             ;a            +      r    :a
#-----------------------------------------------------------------------
# n-2           a[n-2]        n-a[n-2]      a[n-a[n-2]]   a[n]   n      
# n             n             a[n-a[n-1]]   a[n-a[n-1]]   n      a[n]   
# a[n-a[n-1]]   a[n-a[n-1]]   n             n                           
# n             n                                                       

 li;a        # Load index of target element, and fetch that element's current value
             #    Uninitialised values are zero
 0=A         # If a[i]==0, execute A to compute next term
]dsAx        # Close macro definition, store on `A' and execute
li;a         # When we've got enough terms, load target index and push value
f            # Dump stack (a[i]) to stdout

— जो
स्रोत

अंत में, अगर कोई भी आईडीई का निर्माण कर रहा है dc, तो मुझे बताएं!

— जो

0

एर्लैंग, 46 बाइट्स

f(N)when N<3->1;f(N)->f(N-f(N-1))+f(N-f(N-2)).

— CPU1
स्रोत

0

लुआ, 59 बाइट्स

function a(n)return n<3 and 1 or a(n-a(n-1))+a(n-a(n-2))end

— brianush1
स्रोत

हॉफस्टैडर क्यू-सीक्वेंस

परिभाषा

कार्य

परीक्षण के मामलों

संदर्भ

रेटिना , 84 83 79 74 बाइट्स

हास्केल, 35 33 बाइट्स

जूलिया, 29 बाइट्स

यह काम किस प्रकार करता है

सेसोस, 54 बाइट्स

disassembled

सी, 43 42 बाइट्स

गणितज्ञ, 36 बाइट्स

जेली , 15 14 बाइट्स

यह काम किस प्रकार करता है

जेली , 14 12 11 बाइट्स

यह काम किस प्रकार करता है

पायथन, 45 40 बाइट्स

हास्केल, 39 37 बाइट्स

आर, 50 बाइट्स

CJam, 19 18 बाइट्स

सी #, 51 44 बाइट्स

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स 34 बाइट्स

गोल्फस्क्रिप्ट, 29 बाइट्स

05AB1E, 29 बाइट्स

एपीएल, 20 बाइट्स

VBA Excel 87 बाइट्स

रूबी, 36 बाइट्स

जावा 7, 68 61 51 बाइट्स

ओएसिस , ९ asis ५ बाइट्स (गैर-प्रतिस्पर्धात्मक)

PowerShell v2 +, 85 79 69 बाइट्स

पुनरावर्ती समाधान 78 76 बाइट्स

जावास्क्रिप्ट (ईएस 6), 66 बाइट्स

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

फोर्थ, 76 बाइट्स

मेपल, 43 41 बाइट्स

जे, 29 28 बाइट्स

प्रयोग

व्याख्या

डीसी, 62 बाइट्स

एर्लैंग, 46 बाइट्स

लुआ, 59 बाइट्स