प्रथम-एन फाइबोनैचि अनुक्रम तत्व

Question

यहाँ एक प्रसिद्ध प्रश्न है जो एक छोटे (कम से कम वर्णों) फ़ुटबॉल अनुक्रम जनरेटर के लिए पूछता है।

मैं जानना चाहूंगा कि क्या कोई व्यक्ति केवल पहले N तत्वों को, बहुत कम जगह में, रिट्रेसमेंट अनुक्रम में उत्पन्न कर सकता है। मैं इसे अजगर में करने की कोशिश कर रहा हूं, लेकिन मैं किसी भी भाषा में, किसी भी छोटे जवाब में दिलचस्पी लेता हूं। फंक्शन एफ (एन) अनुक्रम के पहले एन तत्वों को उत्पन्न करता है, या तो उन्हें फ़ंक्शन की वापसी के रूप में वापस करता है या उन्हें प्रिंट करता है।

दिलचस्प है कि ऐसा लगता है कि कोड-गोल्फ उत्तर 1 1 2इसके बजाय, के साथ शुरू होते हैं 0 1 1 2। क्या यह कोड-गोल्फ या प्रोग्रामिंग-इन-जनरल में एक सम्मेलन है? (विकिपीडिया का कहना है कि रिट्रेसमेंट अनुक्रम शून्य से शुरू होता है।)

अजगर का नमूना (पहले 5 तत्व):

def f(i,j,n):
    if n>0:
        print i;
        f(j,i+j,n-1)
f(1,1,5)

Comments

मुझे लगता है कि यह भी जुड़े हुए प्रश्न के समान है। पहले एन मामले को संभालने के लिए अधिकांश समाधान आसानी से संशोधित किए जा सकते हैं।

— हमार

हर जगह मैंने देखा है, आधार मामलों को F_0 = 0, F_1 = 1या समकक्ष रूप से परिभाषित किया गया है F_1 = 1, F_2 = 1। अंतर यह है कि क्या आप अनुक्रम 0 (प्रोग्रामिंग में अधिक सामान्य) या 1 (गणित में अधिक सामान्य) पर अनुक्रम शुरू करना चाहते हैं।

— हमार

और F_0 = 0, F_1 = 1मैट्रिक्स प्रतिनिधित्व के साथ सादगी में परिभाषित करने का एक निश्चित लाभ है [[1 1][1 0]]^n = [[F_{n+1} F_n][F_n F_{n-1}]]।

— पीटर टेलर

@ पेटर: अब जब कि एक दूसरे को पसंद करने का एक अच्छा कारण (मैं लंबे समय से 0 पसंद कर रहा हूं, 1 एस्थेटिक मैदान पर, लेकिन उन पर और खुद को दबाने में विश्वास नहीं करता)।

— dmckee --- पूर्व-संचालक बिल्ली का बच्चा

मुझे लगता है कि यह इस बिंदु पर काफी पुरानी चुनौती है, लेकिन ध्यान दें कि आपने एक जवाब स्वीकार किया है जो सबसे छोटा नहीं है। चूंकि यह एक कोड गोल्फ प्रतियोगिता है, इसलिए सबसे छोटा उत्तर वही होना चाहिए जिसे स्वीकार किया गया हो।

— एलेक्स ए।

Answer 1

सी

काउंटिंग में परेशान नहीं किया, लेकिन यहाँ एक मजेदार उदाहरण है:

f(n){return n<4?1:f(--n)+f(--n);}
main(a,b){for(scanf("%d",&b);a++<=b;printf("%d ",f(a)));}

प्रमाण यह काम करता है।

---

मुझे इस पर काफी गर्व है: मैं ऊब गया था, इसलिए मैंने अपने कोड (कुछ छोटे परिवर्धन के साथ) को फिर से बनाने के लिए इसे बनाया जहां प्रत्येक पंक्ति फाइबोनैचि अनुक्रम में एक मूल्य का प्रतिनिधित्व करती है।

                         #                                // 1
                         f                                // 1
                         //                               // 2
                        (n)                               // 3
                       {/**/                              // 5
                      return n                            // 8
                    <2 ? 1:f(--n)                         // 13
                +f(--n); } main(a, b)                     // 21
          {a = 0, b = 0;scanf("%d",&b); for(              // 34
;a < b; a+=1) { int res = f(a); printf("%d ", res); } }   // 55

प्रमाण यह काम करता है।

Comments

अच्छा लगा। 90 चार्ट (बिना न्यूलाइन के)। 2 बाइट्स सहेजें: a++<=b-> a++-bऔर return--n<3?1:f(n)+f(n-1)। इसके अलावा scanfअगर आप n की आवश्यकता होती है तो आप इससे बच सकते हैं argc।

— बदसूरत

इसे प्यार करना! यह एक महान उदाहरण है जहां --nएक ही अभिव्यक्ति में दो उदाहरणों के आदेश का अपरिभाषित व्यवहार अप्रासंगिक है। प्रतिभाशाली!

— टॉड लेहमन

वैसे, मुझे लगता है कि आपका 4वास्तव में होना चाहिए 3। जैसा कि वर्तमान में लिखा गया है <4, निर्मित क्रम 1, 1, 1, 2, 3, 5, 8 है ... यह एक बहुत 1 का है।

— टॉड लेहमैन

इसके अतिरिक्त, यदि आप अनुक्रम के शून्य तत्व को सही ढंग से संभालना चाहते हैं, तो आप 2 वर्ण जोड़ सकते हैं और कोड को बदल सकते हैंreturn n<3?n>0:f(--n)+f(--n);

— टोड लेहमैन

Answer 2

हास्केल (26)

हैरानी की बात यह है कि यह J समाधान से केवल एक वर्ण लंबा है।

च = ( `take`s)
रों = 0: scanl (+) 1s

मैं कुछ पात्रों को शेव करता हूं:

1. takeबाइनरी ऑपरेटर के रूप में उपयोग करना ;
2. क्रिया के scanlस्थान पर प्रयोग करना zipWith।

Comments

यह समझने में मुझे लगभग आधा घंटा लग गया कि यहाँ क्या चल रहा है, और sयह कितना सुरुचिपूर्ण है, मुझे नहीं पता कि कोई भी इस तरह के समाधान के बारे में कैसे सोचेगा! मुझे नहीं पता था कि आप sपरिभाषित करते समय फिर से उपयोग कर सकते हैं s। (मैं अभी भी एक शुरुआत =)

— निर्दोष

Answer 3

यहाँ एक-लाइनर पायथन है। यह फ्लोटिंग-पॉइंट का उपयोग करता है, इसलिए कुछ ऐसे हो सकते हैं nजिनके लिए यह अब सटीक नहीं है।

F=lambda n:' '.join('%d'%(((1+5**.5)/2)**i/5**.5+.5)for i in range(n))

F(n)nरिक्त स्थान द्वारा अलग किए गए पहले फाइबोनैचि संख्या वाले स्ट्रिंग लौटाता है ।

Comments

मैं ऐसा करने के बारे में सोच रहा था, लेकिन सोचा कि यह बहुत लंबा होगा। मैंने फर्श का उपयोग करने के बारे में नहीं सोचा था। बहुत अच्छा।

— क्रिश हार्पर

आह, बिनेट का सूत्र। मैंने इसका उपयोग किया और यह सही है, कम से कम 59 वीं संख्या तक अगर आप पहले की तरह 0 की गिनती करते हैं। उसके बाद संख्या बहुत बड़ी हो जाती है और यह घातांक का उपयोग करने लगता है।

— एलसर

फ़ंक्शन को परिभाषित करने के लिए 70 वर्ण, 1 पंक्ति। + 4 + समतल करने के लिए। काफी अच्छा!

— वारेन पी

Answer 4

GolfScript, 16 अक्षर

~0 1@{.2$+}*;;]`

उदाहरण आउटपुट:

$ ruby golfscript.rb ~/Code/golf/fib.gs <<< "12"
[0 1 1 2 3 5 8 13 21 34 55 89]

Answer 5

पर्ल, 50 अक्षर

sub f{($a,$b,$c)=@_;$c--&&say($a)&&f($b,$a+$b,$c)}

Answer 6

स्केल 71:

def f(c:Int,a:Int=0,b:Int=1):Unit={println(a);if(c>0)f(c-1,b,a+b)};f(9)

प्रिंट

0
1
1
2
3
5
8
13
21
34

Comments

ठंडा। मैंने अभी तक स्काला के साथ नहीं खेला है। मैं इसे आज रात घर पर आजमाऊंगा।

— वारेन पी

Answer 7

पर्ल, 29 28 बाइट्स

perl -E'say$b+=$;=$b-$;for-pop..--$;' 8
1
1
2
3
5
8
13
21

व्याख्या

यह क्लासिक $b += $a = $b-$aपुनरावृत्ति पर आधारित है जो निम्नानुसार काम करता है:

• प्रत्येक लूप की शुरुआत में $aहोता है F(n-2)और $bइसमें शामिल होता हैF(n)
• के बाद $a = $b-$a $aहोता हैF(n-1)
• के बाद $b += $a $bहोता हैF(n+1)

यहां समस्या प्रारंभिक है। शास्त्रीय तरीका है, $b += $a = $b-$a || 1लेकिन फिर अनुक्रम जाता है1 2 3 5 ...

बाईं ओर रिट्राइव अनुक्रम का विस्तार करके:

... 5 -3 2 -1 1 0 1 1 2 3 5 ...

आप देखते हैं कि उचित प्रारंभिक बिंदु $a = -1और है $b = 0। लूप की स्थापना के साथ प्रारंभिक $ एक जोड़ा जा सकता है

अंत में की जगह $aसे $;पहले अंतरिक्ष से छुटकारा पाने केfor

Answer 8

मैं आपको एक दो लाइन पायथन समाधान दे सकता हूं। यह उन्हें एक सूची के रूप में वापस कर देगा।

f = lambda n: 1 if n < 2 else f(n-1) + f(n-2)
g = lambda m: map(f, range(0,m))

print g(5)

आप उन्हें स्ट्रिंग्स बनाने के लिए एक और नक्शा जोड़कर और फिर एक जोड़ जोड़कर उन्हें प्रिंट कर सकते थे, लेकिन यह सिर्फ मुझे अनावश्यक लगता है।

दुर्भाग्य से मैं नहीं जानता कि कैसे एक पुनरावर्ती मेमने में डाल दिया map, इसलिए मैं दो लाइनों में फंस गया हूँ।

Comments

यह किस लिए लौटा है g(100)? ;)

— श्री लामा

@ गीगावाट हेह, ओपी ने कभी भी यह उचित नहीं कहा। क्या एसिम्प्टोटिक रनिंग टाइम कुछ O (n (1.62) ^ n) जैसा है?

— क्रिश हार्पर

यहाँ एक तरह से आप ऐसा कर सकते हैं। कि नोट f(n)के साथ n<=0रिटर्न पूर्णांकों, और n>0रिटर्न सूचियों, तो .. शायद यह नहीं आदर्श है:f = lambda n: map(f, (-x for x in range(0, n))) if n > 0 else -n if n > -2 else f(n+1) + f(n+2)

— डिलन cower

वैसे, आप 0अपने उत्तर में पहले से चूक गए । fवापसी करने के लिए बदलना n if n < 2एक समाधान है। :)

— डिलन कॉवर

@ डीडी मुझे आपका समाधान पसंद है। बहुत रचनात्मक। हाँ, मैंने अपनी शुरुआत 1, 1 से की है, क्योंकि मैंने हमेशा इसे सीखा है। मुझे लगा कि इसे बदलना काफी आसान है।

— क्रिश हार्पर

Answer 9

पायथन (78 वर्ण)

मैंने रिट संख्याओं की गणना करने के लिए Binet के सूत्र का उपयोग किया -

[(1 + sqrt (5)) ^ n- (1-sqrt (5) ^ n] / [(2 ^ n) sqrt (5)]

यह अन्य उत्तरों में से कुछ के रूप में छोटा नहीं है, लेकिन लड़का यह तेज है

n=input()
i=1
x=5**0.5
while i<=n:
    print ((1+x)**i-(1-x)**i)/((2**i)*x)
    i+=1

Comments

पायथन (12 वर्ण): print"11235":)

— जोएल कॉर्नेट

आप चारों ओर कोष्ठक से छुटकारा पाकर 2 वर्णों को काट सकते हैं 2**i। **से अधिक पूर्वता है*

— जोएल कॉर्नेट

बिनेट के फॉर्मूले में दूसरा कार्यकाल छोटा शुरू होता है और केवल छोटा होता है। आप इसे पूरी तरह से छोड़ सकते हैं और पहले पूर्णांक के परिणाम को निकटतम पूर्णांक के बजाय गोल कर सकते हैं (या 0.5 और नीचे जोड़ सकते हैं)

— टन हास्पेल

Answer 10

योजना

यह पूंछ-पुनरावृत्ति का उपयोग करके अनुकूलित किया गया है:

(define (fib n)
  (let fib ([n n] [a 0] [b 1])
    (if (zero? n) (list a)
        (cons a (fib (- n 1) b (+ a b))))))

Answer 11

हास्केल

fib n = take n f
f = 0:1:zipWith (+) f (tail f)

प्रमाण है कि यह काम करता है ।

Comments

आप इसे एक फ़ंक्शन का उपयोग करके बना सकते हैं जहां

— हौलेथ

Answer 12

जे, 25 अक्षर

मुझे पता है कि जे समाधान शायद आप के बाद नहीं हैं, लेकिन यहाँ वैसे भी एक है। :-)

0 1(],+/&(_2&{.))@[&0~2-~

उपयोग:

    0 1(],+/&(_2&{.))@[&0~2-~ 6
0 1 1 2 3 5
    0 1(],+/&(_2&{.))@[&0~2-~ 10
0 1 1 2 3 5 8 13 21 34

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

दाएं से शुरू करना (क्योंकि J प्रोग्राम को दाएं से बाएं पढ़ा जाता है),

2-~ 6~ऑपरेटर क्रिया करने के लिए तर्क को उलट देता तो यह रूप में ही है6-2

अब के लिए कोष्ठक में अनुभाग को अनदेखा करना, 0 1(...)@[&0~ xक्रिया को कोष्ठक में लेता है और xसूची का उपयोग करते हुए इसे कई बार निष्पादित करता है 0 1- ~फिर से यहाँ तर्कों को उलट देता है, जिससे x (...)@[&0 ] 0 1अर्थ है कि मैं फ़ंक्शन के अंत में इनपुट रख सकता हूं।

कोष्ठकों के भीतर एक कांटा है ],+/&(_2&{.)- जो तीन क्रियाओं से बना है ], ,और +/&(_2&{.)।

एक कांटा तीन क्रियाओं को लेता है a b cऔर उन्हें इस तरह उपयोग करता है: (x a y) b (x c y)जहां xऔर yकांटे के तर्क हैं। ,इस कांटा में केंद्र क्रिया है और के परिणामों मिलती है x ] yऔर x +/&(_2&{.) yएक साथ।

]बचा हुआ तर्क लौटाता है इसलिए x ] yमूल्यांकन करता है x।

+/&(_2&{.)दी गई सूची से अंतिम दो आइटम लेता है (_2&{.)- इस मामले में 0 1- और फिर उन्हें एक साथ जोड़ता है +/( &एस सिर्फ गोंद के रूप में कार्य करता है)।

एक बार क्रिया संचालित हो जाने के बाद एक बार परिणाम अगले भाग के लिए वापस भेज दिया जाता है, जिससे अनुक्रम उत्पन्न होता है।

Answer 13

टीआई-बेसिक, 43 अक्षर

:1→Y:0→X
:For(N,1,N
:Disp X
:Y→Z
:X+Y→Y
:Z→X
:End

इस कोड को सीधे मुख्य कार्यक्रम में डाला जा सकता है, या पहले से संदर्भित एक अलग कार्यक्रम में बनाया जा सकता है।

Comments

यह पहला TI-BASIC समाधान है जिसे मैंने कभी यहाँ देखा है जो मेरे द्वारा नहीं था :) +1

— टाइमटेक

इसके अलावा, अन्य लोगों के लिए ध्यान दें कि नई सूचियों को यहां नहीं गिना जाता है क्योंकि उन्हें हटाया जा सकता है।

— टाइमटेक

मुझे अभी-अभी TI-92 बड़ा-विशाल-क्यूवर्टी-कीबोर्ड कैलकुलेटर मिला है। इसके लिए धन्यवाद।

— वॉरेन पी।

Answer 14

एपीएल (33)

{⍎'⎕','←0,1',⍨'←A,+/¯2↑A'⍴⍨9×⍵-2}

उपयोग:

   {⍎'⎕','←0,1',⍨'←A,+/¯2↑A'⍴⍨9×⍵-2}7
0 1 1 2 3 5 8

Comments

बॉक्स चरित्र or एपीएल का हिस्सा है या एक लापता-ग्लिफ़ है?

— वॉरेन पी।

@WarrenP: अगर आपका मतलब बाईं ओर से 4 वर्ण है, तो इसे 'क्वाड' कहा जाता है और यह वैसा ही दिखने वाला है। केवल एक बॉक्स होना चाहिए।

— मारिनस

Answer 15

अजगर (55)

a,b=0,1

for i in range(int(input())):a,b=b,a+b;print(b)

Answer 16

पॉवर्सशेल - 35 अक्षर

पॉवर्सशेल पाइपलाइन इनपुट को स्वीकार करता है , इसलिए मुझे विश्वास है कि n |मेंn | <mycode> मेरी गिनती के खिलाफ नहीं होना चाहिए, लेकिन इसके बजाय सिर्फ भाषा में एक "समारोह" की शुरुआत का एक हिस्सा है।

पहला समाधान हम 0 से शुरू करते हैं:

%{for($2=1;$_--){($2=($1+=$2)-$2)}}

दूसरा समाधान हम 1 पर शुरू कर सकते हैं:

%{for($2=1;$_--){($1=($2+=$1)-$1)}}

उदाहरण आह्वान: 5 | %{for($2=1;$_--){($1=($2+=$1)-$1)}}

पैदावार:

1
1
2
3
5

दिलचस्प है, for()लूप के ओवरहेड से बचने का प्रयास एक ही वर्ण गणना में हुआ %{$2=1;iex('($1=($2+=$1)-$1);'*$_)}:।

Answer 17

पायथन, 43 वर्ण

यहां तीन मौलिक रूप से अलग-अलग एक-लाइनर हैं जो कि बिनेट के फार्मूले का उपयोग नहीं करते हैं।

f=lambda n:reduce(lambda(r,a,b),c:(r+[b],a+b,a),'.'*n,([],1,0))[0]
f=lambda n:map(lambda x:x.append(x[-1]+x[-2])or x,[[0,1]]*n)[0]
def f(n):a=0;b=1;exec'print a;a,b=b,a+b;'*n

मैंने कभी reduceइतनी बुरी तरह से गाली नहीं दी ।

Comments

reduceदुरुपयोग के लिए +1

— वॉरेन पी

Answer 18

डीसी, 32 अक्षर:

यह वास्तव में हमेशा दो पहले 1 दिखाएगा, इसलिए फ़ंक्शन केवल N> = 2 के लिए अपेक्षित रूप से काम करता है ।

?2-sn1df[dsa+plarln1-dsn0<q]dsqx

सी, 75 अक्षर:

स्वीकार किए जाते हैं उत्तर के रूप में शांत नहीं है, लेकिन कम और तेजी से रास्ता:

main(n,t,j,i){j=0,i=scanf("%d",&n);while(n--)t=i,i=j,printf("%d\n",j+=t);}

अतिरिक्त:

सीएल, 64 अक्षर:

मेरी सबसे अधिक इस्तेमाल किया में से एक बुकमार्क इस सत्र एक दिलचस्प उदाहरण है जो की तुलना में कम है कई अन्य लोगों को यहाँ से कुछ, और यह सिर्फ एक सीधी-सपाट मंगलाचरण है loopमैक्रो - सिर्फ एक बयान मूल रूप से! सभी व्हाट्सएप के लिए मैंने इसे छीन लिया:

(loop repeat n for x = 0 then y and y = 1 then(+ x y)collect y)

काफी छोटा, और अच्छा और पठनीय! इनपुट पढ़ने के लिए, n (आसपास के व्हाट्सएप सहित) को (read)3 अक्षरों को जोड़कर बदला जा सकता है ।

Comments

करता है ... mainचार तर्क लेता है?

— बिल्ली

जितना देते हो, उतना ही लगता है। इस मामले में यह सिर्फ (ab) कुछ चरों को परिभाषित करने के लिए उपयोग किया जाता है जो बाद में उपयोग किए जाते हैं :)

— daniero

Answer 19

FALSE, 28 बाइट्स

0 1- 1 10[$][@@$@+$." "@1-]#

Comments

आप उत्पन्न कर सकते हैं -1 का उपयोग कर 1_के बजाय0 1 -

— 12Me21

Answer 20

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

पहले से पोस्ट किए गए समाधान पर सुधार:

a=b=1
exec'print a;a,b=b,a+b;'*input()

यह execछोरों से बचने के लिए स्ट्रिंग और गुणन का उपयोग करता है ।

पायथन 3, 46 बाइट्स

पायथन 3 में काफी कुशल नहीं:

a=b=1
exec('print(a);a,b=b,a+b;'*int(input()))

Comments

अजगर 2 पर स्विच करके आप 9 बाइट बचा सकते हैं: इसे ऑनलाइन आज़माएं! आप शायद अपने उत्तर में पायथन 2 संस्करण जोड़ सकते हैं।

— स्टीफन

@Stephen अच्छा बिंदु! अपडेट किया गया।

— रसेल श्वार्ट्ज

Answer 21

C99, 58 अक्षर

निम्न फ़ंक्शन n0 से शुरू होने वाले फाइबोनैचि अनुक्रम से पहले मानों के साथ पूर्णांकों की एक सरणी भरता है ।

void f(int*a,int n){for(int p=0,q=1;n--;q+=*a++)*a=p,p=q;}

nकमांड लाइन तर्क के रूप में टेस्ट हार्नेस :

#include <stdlib.h>
#include <stdio.h>
int main(int argc, char *argv[]) {
     int n = (argc > 1) ? atoi(argv[1]) : 1;
     int a[n];
     f(a, n);
     for (int i = 0; i < n; ++i)
          printf("%d\n", a[i]);
}

Answer 22

कॉफ़ीस्क्रिप्ट, 48

f=(n,i=1,j=1)->(console.log i;f n-1,j,i+j)if n>0

65 js में:

function f(n,i,j){if(n>0)console.log(i),f(n-1,(j=j||1),(i||1)+j)}

Answer 23

PHP, 87

function f($n,$a=array(0,1)){echo' '.$a[0];$n>0?f(--$n,array($a[1],array_sum($a))):'';}

array_sumश्रृंखला उत्पन्न करने के लिए उपयोग और पुनरावर्ती कार्य करता है ।

उदाहरण के लिए:

 $ php5 fibo.php 9
 0 1 1 2 3 5 8 13 21 34 

Answer 24

एफ #, 123

let f n = Seq.unfold(fun (i,j)->Some(i,(j,i+j)))(0,1)|>Seq.take n
f 5|>Seq.iter(fun x->printfn "%i" x)

Answer 25

स्काला, 65 वर्ण

(Seq(1,0)/:(3 to 9)){(s,_)=>s.take(2).sum+:s}.sorted map println

यह प्रिंट, उदाहरण के लिए, पहले 9 फाइबोनैचि संख्या। कंसोल इनपुट से अनुक्रम लंबाई लेने वाले अधिक उपयोग करने योग्य संस्करण के लिए, 70 वर्णों की आवश्यकता होती है:

(Seq(1,0)/:(3 to readInt)){(s,_)=>s.take(2).sum+:s}.sorted map println

सीमा के उपयोग से सावधान रहें इसे Int मानों तक सीमित करें।

Answer 26

क्यू 24

f:{{x,sum -2#x}/[x;0 1]}

पहले एन रिट्रेसमेंट नंबर

Answer 27

लूआ, 85 बाइट्स

मैं लुआ सीख रहा हूं इसलिए मैं इस भाषा को पूल में जोड़ना चाहूंगा।

function f(x)
    return (x<3) and 1 or f(x-1)+f(x-2)
end
for i=1,io.read() do
    print(f(i))
end

और कमांड लाइन तर्क के रूप में पैरामीटर के साथ पूरी बात 85 वर्णों की थी। एक और अच्छी बात यह है कि पढ़ना आसान है।

Answer 28

FALSE, 20 अक्षर

^1@[1-$][@2ø+$.\9,]#

इसे चलाने से पहले स्टैक पर इनपुट होना चाहिए।

Answer 29

Pyt , 3 बाइट्स

ř⁻Ḟ

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

... एक सरणी बनाता है [1, 2, 3, ..., x]
Once हर आइटम को एक बार घटाता है (जैसा कि index 0 अनुक्रमित है)
Fibonacci x में हर आइटम के लिए इसे समरूपित समतुल्य में परिवर्तित करता है

Answer 30

x86 मशीन कोड - 379 बाइट्स

ईएलएफ हेडर के साथ संस्करण 484 बाइट्स स्कोरिंग:

00000000: 7f45 4c46 0101 0100 0000 0000 0000 0000  .ELF............
00000010: 0200 0300 0100 0000 c080 0408 3400 0000  ............4...
00000020: 0000 0000 0000 0000 3400 2000 0200 2800  ........4. ...(.
00000030: 0000 0000 0100 0000 0000 0000 0080 0408  ................
00000040: 0000 0000 e401 0000 0010 0000 0500 0000  ................
00000050: 0010 0000 0100 0000 0000 0000 0090 0408  ................
00000060: 0000 0000 0000 0000 0000 1000 0600 0000  ................
00000070: 0010 0000 0000 0000 0000 0000 0000 0000  ................
00000080: 51b9 0090 0408 8801 31c0 ba01 0000 00eb  Q.......1.......
00000090: 0351 89c1 31c0 89c3 43b0 04cd 8031 c099  .Q..1...C....1..
000000a0: 4259 c300 0000 0000 0000 0000 0000 0000  BY..............
000000b0: 0000 0000 0000 0000 0000 0000 0000 0000  ................
000000c0: 31c0 9942 b903 9004 08c6 4101 0ac6 4102  1..B......A...A.
000000d0: 01c6 4103 013a 7103 0f84 ff00 0000 3a71  ..A..:q.......:q
000000e0: 0374 2680 4103 050f b641 036b c008 0041  .t&.A....A.k...A
000000f0: 048a 4104 e887 ffff ff80 6904 30c6 4103  ..A.......i.0.A.
00000100: 0183 e903 3a71 0375 da8a 4104 e86f ffff  ....:q.u..A..o..
00000110: ff3a 7106 0f84 ba00 0000 0fb6 4105 8841  .:q.........A..A
00000120: 060f b641 0788 4105 0fb6 4107 0041 06c6  ...A..A...A..A..
00000130: 4107 003a 7106 0f84 8800 0000 c641 0701  A..:q........A..
00000140: fe49 063a 7106 0f84 7800 0000 c641 0702  .I.:q...x....A..
00000150: fe49 063a 7106 0f84 6800 0000 c641 0703  .I.:q...h....A..
00000160: fe49 063a 7106 0f84 5800 0000 c641 0704  .I.:q...X....A..
00000170: fe49 063a 7106 744c c641 0705 fe49 063a  .I.:q.tL.A...I.:
00000180: 7106 7440 c641 0706 fe49 063a 7106 7434  q.t@.A...I.:q.t4
00000190: c641 0707 fe49 063a 7106 7428 c641 0708  .A...I.:q.t(.A..
000001a0: fe49 063a 7106 741c c641 0709 fe49 063a  .I.:q.t..A...I.:
000001b0: 7106 7410 fe41 08fe 4109 fe49 060f b641  q.t..A..A..I...A
000001c0: 0688 4107 c641 0601 83c1 033a 7106 0f85  ..A..A.....:q...
000001d0: 46ff ffff 3a71 030f 8501 ffff ffb3 0031  F...:q.........1
000001e0: c040 cd80                                .@..

हेडरलेस वर्जन (जो कि ग्रेडेड किया जाना है):

00000000: 67c6 4101 0a67 c641 0201 67c6 4103 0167  g.A..g.A..g.A..g
00000010: 3a71 030f 842a 0167 3a71 0374 2e67 8041  :q...*.g:q.t.g.A
00000020: 0305 6667 0fb6 4103 666b c008 6700 4104  ..fg..A.fk..g.A.
00000030: 678a 4104 e80d 0167 8069 0430 67c6 4103  g.A....g.i.0g.A.
00000040: 0166 83e9 0367 3a71 0375 d267 8a41 04e8  .f...g:q.u.g.A..
00000050: f200 673a 7106 0f84 df00 6667 0fb6 4105  ..g:q.....fg..A.
00000060: 6788 4106 6667 0fb6 4107 6788 4105 6667  g.A.fg..A.g.A.fg
00000070: 0fb6 4107 6700 4106 67c6 4107 0067 3a71  ..A.g.A.g.A..g:q
00000080: 060f 84a3 0067 c641 0701 67fe 4906 673a  .....g.A..g.I.g:
00000090: 7106 0f84 9200 67c6 4107 0267 fe49 0667  q.....g.A..g.I.g
000000a0: 3a71 060f 8481 0067 c641 0703 67fe 4906  :q.....g.A..g.I.
000000b0: 673a 7106 0f84 7000 67c6 4107 0467 fe49  g:q...p.g.A..g.I
000000c0: 0667 3a71 0674 6167 c641 0705 67fe 4906  .g:q.tag.A..g.I.
000000d0: 673a 7106 7452 67c6 4107 0667 fe49 0667  g:q.tRg.A..g.I.g
000000e0: 3a71 0674 4367 c641 0707 67fe 4906 673a  :q.tCg.A..g.I.g:
000000f0: 7106 7434 67c6 4107 0867 fe49 0667 3a71  q.t4g.A..g.I.g:q
00000100: 0674 2567 c641 0709 67fe 4906 673a 7106  .t%g.A..g.I.g:q.
00000110: 7416 67fe 4108 67fe 4109 67fe 4906 6667  t.g.A.g.A.g.I.fg
00000120: 0fb6 4106 6788 4107 67c6 4106 0166 83c1  ..A.g.A.g.A..f..
00000130: 0367 3a71 060f 8521 ff67 3a71 030f 85d6  .g:q...!.g:q....
00000140: fe00 0000 6651 66b9 7801 0000 6788 0166  ....fQf.x...g..f
00000150: 31c0 66ba 0100 0000 eb05 6651 6689 c166  1.f.......fQf..f
00000160: 31c0 6689 c366 43b0 04cd 8066 31c0 6699  1.f..fC....f1.f.
00000170: 6642 6659 c300 0000 0000 00              fBfY.......

गणना (संभवतः) $\infty$ रिट्रेसमेंट नंबर।