28

यह देखते हुए एन (2 <= एन ), प्रिंट एन पत्र की तर्ज फिबोनैकी श्रृंखला की तरह इस (यानी एन = 5) सबसे पहले, के साथ शुरू aऔर b:

a
b

इसके बाद, दो पंक्तियों को जोड़ें।

a
b
ab

अंतिम दो पंक्तियों को जोड़ते रहें।

a
b
ab
bab

बढ़ा चल...

a
b
ab
bab
abbab

और हम कर रहे हैं।

रिमेम्बर, यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स वाला कोड जीत जाता है।

code-golf string fibonacci

— ओलिवर नी
स्रोत

4

सम्बंधित

— AdmBorkBork

क्या यह एक फ़ंक्शन हो सकता है जो एन तक की शर्तों की सूची लौटाता है?

— 21

क्या हमें परिणाम प्रिंट करना है या हम किसी फ़ंक्शन से स्ट्रिंग की सूची वापस कर सकते हैं?

— nimi

रुको, तो यह n = 1 के लिए काम करने की जरूरत नहीं है?

— सुकरात फीनिक्स

इसके अलावा, क्या हम 0-आधारित अनुक्रमण का उपयोग कर सकते हैं?

— सुकरात फीनिक्स

10

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

3 बाइट @xnor के लिए धन्यवाद सहेजा गया

a,b="ab";exec"print a;a,b=b,a+b;"*input()

Ideone पर परीक्षण

बस पुनरावर्ती परिभाषा का अनुसरण करता है।

— ETHproductions
स्रोत

यह एक कार्यक्रम के रूप में कम है: a,b="ab";exec"print a;a,b=b,a+b;"*input()।

— 23

1

अजगर 2 को निर्दिष्ट करना चाह सकते हैं :)

— FlipTack

8

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

a%b=a:b%(a++b)
(`take`("a"%"b"))

सरल पुनरावृत्ति।

संदर्भ के लिए: पुराने संस्करण ( इस उत्तर का एक अनुकूलन ), गलत क्रम में तार को संक्षिप्त कर दिया, इसलिए मुझे flip(...)इसे जोड़ना पड़ा जिसने इसे बहुत लंबा (35 बाइट्स) बनाया।

f="a":scanl(flip(++))"b"f
(`take`f)

— nimi
स्रोत

आउटपुट उदाहरण से अलग है ( ["b","a","ab","aba","abaab"]

— संघनन

@Angs: उफ़ क्या गलती है! फिक्स्ड।

— निमि

6

05AB1E , 12 11 बाइट्स

बाइट बचाने के लिए एमिग्ना को धन्यवाद !

'a='b¹GD=Š«

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

1

Íƒबस के रूप में अच्छी तरह से Gआप का उपयोग नहीं कर रहे हो सकता है N:)

— Emigna

@Eigna ओह, हाँ, तुम सही हो! धन्यवाद :)!

— अदनान

5

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

”a”bṄ;¥@¡f

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

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

”a”bṄ;¥@¡f  Main link. Argument: n

”a          Set the return value to 'a'.
  ”b    ¡   Call the link to the left n times, with left argument 'b' and right
            argument 'a'. After each call, the right argument is replaced with the
            left one, and the left argument with the return value. The final
            return value is yielded by the quicklink.
      ¥       Combine the two atoms to the left into a dyadic chain.
    Ṅ           Print the left argument of the chain, followed by a linefeed.
     ;          Concatenate the left and right argument of the chain.
       @      Call the chain with reversed argument order.
         f  Filter the result by presence in n. This yields an empty string
            and thus suppresses the implicit output.

— डेनिस
स्रोत

मेरे पास ”a”b;@Ṅहिस्सा कम था, लेकिन मैं यह पता नहीं लगा सका कि वहाँ से कहाँ जाना है ... अब मुझे पता है :-)

— ETHproductions

5

जावा 7, 69 बाइट्स

String c(int n,String a,String b){return n--<1?"":a+"\n"+c(n,b,a+b);}

ungolfed

 class fibb {


public static void main(String[] args) {
    System.out.println( c( 7, "a" , "b" ) );

}
static String c(int n,String a,String b) {

    return n-- < 1  ? "" : a + "\n" + c(n,b,a + b);

}
}

— Numberknot
स्रोत

आपको वास्तव में अपने उत्तरों में अपने अनऑर्गनाइज्ड कोड को थोड़ा और अधिक प्रारूपित करने की आवश्यकता है .. हालांकि xD +1, और यह किसी भी अन्य के लिए काम करता है जो केवल aऔर केवल अलग-अलग स्ट्रिंग्स का काम करता है b। मुझे यकीन नहीं है कि "a"और "b"मापदंडों को बाइट-काउंट की ओर गिना जाना चाहिए, हालांकि प्रश्न विशेष रूप से राज्यों का उपयोग करना चाहिए aऔर b। ऐसा नहीं है कि जावा कभी भी जीत जाएगा। ;)

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

@KevinCruijssen स्ट्रिंग मापदंडों की आवश्यकता होती है क्योंकि उनके मूल्यों को हर बार विधि द्वारा लागू किए जाने पर बदल जाते हैं।

@Snowman मैं जानता हूँ कि वे आवश्यक हैं .. मैं सिर्फ कह रहा है कि बाइट गिनती शायद 75 बाइट (के लिए +6 होना चाहिए "a"और "b") के बजाय 69 क्योंकि चुनौती विशेष रूप से करने के लिए कहा aऔर b, और कोड कतरना / विधि वर्तमान में उपयोग करता है एक चर इनपुट। यह निश्चित नहीं है कि नियम कुछ इस तरह के संबंध में हैं, लेकिन मुझे व्यक्तिगत रूप से लगता है कि इसे गिना जाना चाहिए। अन्यथा आप कुछ भाषाओं में एक फ़ंक्शन हो सकते हैं जो एक पैरामीटर फ़ंक्शन निष्पादित करता है, और फिर बस अपने बाइट्स की गिनती के बिना पैरामीटर में पूरी चुनौती-फ़ंक्शन देता है। एक मानक-लूपोल प्रकार के नियम की तरह लगता है।

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

1

मुझे जावा उत्तर पसंद हैं। वे बाहर बहुत अच्छे हैं - 12 बाइट्स यहाँ, 5 वहाँ, 17 यहाँ ... 70 बाइट्स वहाँ ... रुको, क्या? ओह, यह जावा फिर से है ... +1

— रुडोल्फजेलिन

5

एमएसीएस, 26 , 25-ish कीस्ट्रोक्स

कार्यक्रम

#nअंकों (रों) के साथ कुंजी के रूप में पढ़ने के लिए n :

ARETBRETF3UPUPC-SPACEC-EM-WDOWNDOWNC-Y UPC-AC-SPACEC-EM-WDOWNC-EC-YRETF4C-#(n-2)F4

व्याख्या

command(s)               explanation                      buffer reads (| = cursor aka point)
-----------------------------------------------------------------------------------------------
A<RET> B<RET>            input starting points            "a\nb\n|"
<F3>                     start new macro                  "a\nb\n|"
<UP><UP>                 move point two lines up          "|a\nb\n"
C-<SPACE> C-E M-W        copy line at point               "a|\nb\n"
<DOWN><DOWN>             move point two lines down        "a\nb\n|"
C-Y                      yank (paste)                     "a\nb\na|"
<UP>                     move point one line up           "a\nb|\na"
C-A C-<SPACE> C-E M-W    copy line at point               "a\nb|\na"
<DOWN>                   move point one line down         "a\nb|\na|"
C-E C-Y <RET>            yank (paste) and add new line    "a\nb|\nab\n|"
<F4>                     stop macro recording             "a\nb|\nab\n|"
C-#(n-3) <F4>            apply macro n-3 times            "a\nb|\nab\nbab\nabbab\n|"

एन = 10 के साथ

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab

— YSC
स्रोत

1

मै टूट चुका हूँ। एक तरफ, मैं हमेशा संपादक-गोल्फ को उभारता हूं, लेकिन दूसरी तरफ मैं विम का उपयोग करता हूं। ओह ठीक है, वैसे भी +1। :)

— DJMcMayhem

@DrMcMoylex इसे Cu Mx

— Convert

5

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

@Arnauld को बाइट धन्यवाद दिया

f=(n,a="a",b="b")=>n&&f(n-!alert(a),b,a+b)

— ETHproductions
स्रोत

4

CJam, 19 17 बाइट्स

'a'b{_@_n\+}ri*;;

व्याख्या

"a": Push character literal "a" onto the stack.
"b": Push character literal "b" onto the stack.
{_@_p\+}
    {: Block begin.
    _: duplicate top element on the stack
    @: rotate top 3 elements on the stack
    _: duplicate top element on the stack
    n: print string representation
    \: swap top 2 elements on the stack
    +: add, concat
    }: Block end.
r: read token (whitespace-separated)
i: convert to integer
*: multiply, join, repeat, fold (reduce)
;: pop and discard
;: pop and discard

— Setop
स्रोत

वैसे, वर्तमान में स्ट्रिंग्स की संख्या एक से कम है; पिछले pएक होना चाहिए ;। यदि आप nइसके बजाय उपयोग करते हैं तो आप आउटपुट के आसपास के उद्धरणों से छुटकारा पा सकते हैं p। अंत में, 'a'bदो बाइट्स को बचाता है "a""b"।

— डेनिस

3

वी , 18 बाइट्स

ia
bkÀñyjGpgJkñdj

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

या, अधिक पठनीय संस्करण:

ia
b<esc>kÀñyjGpgJkñdj

स्पष्टीकरण:

ia
b<esc>          " Insert the starting text and escape back to normal mode
k               " Move up a line
 Àñ       ñ     " Arg1 times:
   yj           "   Yank the current line and the line below
     G          "   Move to the end of the buffer
      p         "   Paste what we just yanked
       gJ       "   Join these two lines
         k      "   Move up one line
           dj   " Delete the last two lines

— DJMcMayhem
स्रोत

3

MATL , 14 बाइट्स

97c98ci2-:"yyh

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

97c     % Push 'a'
98c     % Push 'b'
i2-     % Input number. Subtract 2
:"      % Repeat that many times
  yy    %   Duplicate the top two elements
  h     %   Concatenate them

— लुइस मेंडो
स्रोत

3

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

def f(n):m='a','b';exec'print m[-2];m+=m[-2]+m[-1],;'*n

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

3

रेटिना , 33 बाइट्स

.+
$*
^11
a¶b
+`¶(.+?)1
¶$1¶$%`$1

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

बच गए 10 (!) @ मार्टिनएंडर को धन्यवाद !

व्याख्या

एकल, घटाता के लिए इनपुट में कनवर्ट करता है 2और कहते हैं aऔर b, फिर रिकर्सिवली शेष की जगह 1पिछले दो तार के संयोजन के साथ।

— डोम हेस्टिंग्स
स्रोत

अनावश्यक कैप्चर से बचकर कुछ बाइट्स सहेजे: retina.tryitonline.net/…

— मार्टिन

@MartinEnder अच्छा लगा! काफी शक्ति नहीं देखी $%` ! और वह अन्य कब्जा सिर्फ खराब नियोजन था ... कमाल है, धन्यवाद!

— डोम हेस्टिंग्स 10

2

बैच, 102 93 बाइट्स

@set a=a
@set b=b
@for /l %%i in (2,1,%1)do @call:l
:l
@echo %a%
@set a=%b%&set b=%a%%b%

नियत रूप से प्रभावी होने से पहले सौभाग्य से चर का विस्तार हर पंक्ति के लिए किया जाता है, इसलिए मैं अस्थायी की आवश्यकता के बिना दोनों को सेट कर सकता हूं aऔर bअपने पुराने मूल्यों का उपयोग कर सकता हूं । संपादित करें: सहेजे गए 9 बाइट @ nephi12 की बदौलत।

— नील
स्रोत

मैं ऐसा करने वाला था;) वैसे, आप "बाहर / बी" को हटाकर 8 बाइट्स बचा सकते हैं और 2 से अपना लूप शुरू कर सकते हैं:for /l %%i in (2,1,%1) etc..

— nephi12

सेट कमांड को उसी लाइन पर रखकर एक और (न्यूलाइन) @set a=a&set b=bजैसा आपने पिछले एक के साथ किया था। हालांकि तकनीकी रूप से वे सभी एक ही लाइन पर हो सकते हैं ... लेकिन यह बदसूरत होगा ... हम्म ...

— nephi12

2

मेरे गोल्फ को ढेर करो, 63 बाइट्स

: मेरे यहाँ भाषा जाओ https://github.com/cheertarts/Stack-My-Golf ।

($1=(_(a))($2=(_(b))($2-f:1-f,)?)?)f\($1=(f)($1-p(\n),:f,)?)p\p

शायद एक छोटा रास्ता है लेकिन यह सबसे स्पष्ट है।

— क्विंसी बी
स्रोत

2

पर्ल, 36 35 बाइट्स

के लिए +3 शामिल है -n

STDIN पर गिनती दें

perl -M5.010 fibo.pl <<< 5

fibo.pl

#!/usr/bin/perl -n
$_=$'.s/1//.$_,say$`for(a1.b)x$_

— टन हास्पेल
स्रोत

2

पर्ल, 45 +1 = 46 बाइट्स

+1 बाइट -n फ़्लैग के लिए

$a=a,$b=b;say($a),($a,$b)=($b,$a.$b)for 1..$_

मौजूदा 49-बाइट समाधान पर थोड़ा सुधार, लेकिन अलग से विकसित। के लिए कोष्ठक say($a)आवश्यक हैं क्योंकि, अन्यथा, यह $a,($a,$b)=($b,$a.$b)तर्क के रूप में व्याख्या करता है कि sayहम जरूरत से ज्यादा कबाड़ का उत्पादन करते हैं।

पर्ल, 42 बाइट्स

$b=<>;$_=a;say,y/ab/bc/,s/c/ab/g while$b--

उपरोक्त समाधान से एक अलग दृष्टिकोण:

$b=<>;                                       #Read the input into $b
      $_=a;                                  #Create the initial string 'a' stored in $_
           say                               #Print $_ on a new line
               y/ab/bc/                      #Perform a transliteration on $_ as follows:
                                   #Replace 'a' with 'b' and 'b' with 'c' everywhere in $_
                        s/c/ab/g             #Perform a replacement on $_ as follows:
                                   #Replace 'c' with 'ab' everywhere in $_
              ,        ,         while$b--   #Perform the operations separated by commas
                                   #iteratively as long as $b-- remains truthy

मैं अभी तक आश्वस्त नहीं हूं कि मैं लिप्यंतरण और प्रतिस्थापन को एक एकल, छोटे ऑपरेशन में जोड़ नहीं सकता। अगर मुझे एक मिलता है, तो मैं इसे पोस्ट करूंगा।

— गेब्रियल बेनामी
स्रोत

1

स्विफ्ट 3, 76 बाइट्स

func f(_ n:Int,_ x:String="a",_ y:String="b"){if n>1{print(x);f(n-1,y,x+y)}}

— अलेक्जेंडर - मोनिका को बहाल करें
स्रोत

1

पर्ल, 48 बाइट्स

47 बाइट्स कोड + 1 के लिए -n।

सरल दृष्टिकोण। मूल रूप से एक सरणी स्लाइस का उपयोग करने का प्रयास करें, $a[@a]="@a[-2,-1]"लेकिन यह आवश्यक है $"=""या समान है :( सहेजें 1 @ बाइट के लिए धन्यवाद @ दादा !

@;=(a,b);$;[@;]=$;[-2].$;[-1]for 3..$_;say for@

प्रयोग

perl -nE '@;=(a,b);$;[@;]=$;[-2].$;[-1]for 3..$_;say for@' <<< 5
a
b
ab
bab
abbab

— डोम हेस्टिंग्स
स्रोत

आप का उपयोग करके एक बाइट बचा सकता है @;के बजाय @aतो आप अंतिम अर्धविराम छोड़ सकते हैं (देखें मैं क्या मतलब है?)। (मुझे पता है, एक बाइट बहुत सस्ता है, लेकिन मेरे पास कोई बेहतर विचार नहीं था ..)

— दादा

@ दादा हाँ, मैंने कोशिश की थी, लेकिन यह मेरी मशीन पर संकलन नहीं कर सकता है, इसलिए मैंने सोचा कि शायद वहाँ कुछ अजीब चल रहा है:

perl -pe '@;=(a,b);$;[@;]=$;[-2].$;[-1]for 3..$_;say for@' <<< 5    syntax error at -e line 1, at EOF    Execution of -e aborted due to compilation errors.

लेकिन मुझे नहीं लगा कि यह एक जवाब के रूप में जोड़ना उचित होगा अगर मैं नहीं कर सकता था यह काम करो!

— डोम हेस्टिंग्स

यकीन है कि यह के -peबजाय से संबंधित नहीं है -nE? किसी भी तरह से, यह मेरा काम करता है, इसलिए यह संभवतः आपके पर्ल संस्करण या सिस्टम से संबंधित है ... लेकिन मुझ पर भरोसा करें, मैंने इसे परीक्षण किया और यह काम करता है! ;)

— दादा

@ दादा मुझे भी साथ मिलता है -nE(पता नहीं कहाँ से -peआया है! शुक्रवार होना चाहिए ...) मैं इसे अपडेट करूँगा जब मुझे मो मिलेगा! साझा करने के लिए धन्यवाद!

— डोम हेस्टिंग्स 13

1

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

 a b.{;t⁴+

स्पष्टीकरण:

 a b.{;t⁴+                                        stack on 1st cycle
 a              push "a"                               ["a"]
   b            push "b"                               ["a","b"]
    .{          repeat input times                     ["a","b"]
      ;         swap the two top things on the stack   ["b","a"]
       t        output the top thing on the stack      ["b","a"]
        ⁴       copy the 2nd from top thing from stack ["b","a","b"]
         +      join them together                     ["b","ab"]

यह गैर-प्रतिस्पर्धात्मक है क्योंकि यह भाषा अभी भी विकास में है और मैंने इसे लिखते समय कुछ नए कार्य जोड़े हैं।

इसके अलावा, PPCG पर पहली पोस्ट!

— dzaima
स्रोत

1

PPCG में आपका स्वागत है! महान पहली पोस्ट!

— ओलिवर नी

1

05AB1E, 15 बाइट्स

'a'bVUFX,XYUYJV

1

सी , 156 बाइट्स (इंडेंट के बिना)

void f(int n)
{
    char u[999]="a",v[999]="b",*a=u,*b=a+1,*c=v,*d=c+1,*e,i;
    for(i=0;i<n;++i)
    {
        printf("%s\n",a);
        for(e=c;*b++=*e++;);
        e=a;a=c;c=e;e=b+1;b=d;d=e;
    }
}

दो बफ़र्स (u & v) अंतिम दो पंक्तियों को संग्रहीत करते हैं। नवीनतम पंक्ति (दो बिंदुओं के साथ ट्रैक की गई: प्रारंभ = c, अंत = d) सबसे पुरानी एक (प्रारंभ = a, अंत = b) से जुड़ी है। स्वैप (ए, बी) और (सी, डी), और लूप। बहुत अधिक लाइनों का अनुरोध करने से पहले बफर आकार पर ध्यान दें। इतना कम नहीं (जैसा कि निम्न-स्तरीय भाषा से अपेक्षित है), लेकिन कोड के लिए मजेदार था।

— फिल
स्रोत

आपने हार्डकॉस्ट किया, 5लेकिन यह उपयोगकर्ता इनपुट होना चाहिए

— कार्ल नैप

हम्म ... मुझे पहेली में आवश्यकता के रूप में "उपयोगकर्ता इनपुट" दिखाई नहीं दे रहा है ... पर्ल, पायथन, सी ++ के समान पथ के बाद ... उत्तर, "इंट मुख्य ()" को "शून्य एफ (इंट) के साथ बदलें एन) "।

— फिल

Given N (2 <= N), print N lines of the letter Fibonacci series like this (i.e. N = 5)

— कार्ल नैफ

खैर, शब्दों के शब्द में यूजर इनपुट एक बुरा विकल्प था। मेरा मतलब डायनेमिक की तरह था और Nफिक्स्ड नहीं था। या उपयोगकर्ता कोई हो सकता है जो आपके फ़ंक्शन / प्रोग्राम का उपयोग करता है।

— कार्ल नैप

मैंने बेवकूफ टर्मिनेटर की नकल नहीं करने के बारे में एक बेवकूफ गलती को ठीक किया है। मैंने फ़ंक्शन को अधिक पठनीय स्थिति में भी रखा है (एक लाइनर मजाकिया है, लेकिन काम नहीं है)। वास्तव में इस फ़ंक्शन का परीक्षण करने के लिए, इसका उपयोग करें: int main (int n, char ** p) {f (n <2; 5: atoi (p [1])); वापसी 0;}

— Phil

1

PHP, 63 62 बाइट्स

पुनरावर्ती संस्करण:

function f($n,$a=a,$b=b){return$n--?"$a
".f($n,$b,$a.$b):'';}

— क्रिप्टो
स्रोत

अनावश्यक व्हॉट्सएप के बादreturn

— टाइटस

0

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

J,\a\bjP.U=+Js>2J

एक प्रोग्राम जो एक पूर्णांक का इनपुट लेता है और परिणाम को प्रिंट करता है।

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

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

J,\a\bjP.U=+Js>2J  Program. Input: Q
 ,\a\b             Yield the two element list ['a', 'b']
J                  Assign to J
        .U         Reduce over [0, 1, 2, 3, ..., Q] (implicit input):
          =J+        J = J +
              >2J     the last two elements of J
             s        concatenated
       P           All of that except the last element
      j            Join on newlines
                   Implicitly print

— TheBikingViking
स्रोत

0

पायथ - 16 15 बाइट्स

A"ab" m=H+
~GHH

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

— Maltysen
स्रोत

0

एपीएल, 30 बाइट्स।

⎕IOहोना ही चाहिए 1।

{⎕←⍵}¨{⍵∊⍳2:⍵⌷'ab'⋄∊∇¨⍵-⌽⍳2}¨⍳

— Zacharý
स्रोत

0

मैथेमेटिका, 49 बाइट्स

f@1="a";f@2="b";f@n_:=f[n-2]<>f[n-1];g=f~Array~#&

gएकल संख्यात्मक इनपुट लेने वाले फ़ंक्शन को परिभाषित करता है ; तार की सूची देता है। स्ट्रिंग-जॉइनिंग ऑपरेटर का उपयोग करते हुए, सीधा पुनरावर्ती कार्यान्वयन <>।

मैथेमेटिका, 56 बाइट्स

NestList[#~StringReplace~{"a"->"b","b"->"ab"}&,"a",#-1]&

फ़ंक्शन, ऊपर के रूप में एक ही इनपुट / आउटपुट प्रारूप। यह समाधान स्ट्रिंग्स उत्पन्न करने के लिए एक वैकल्पिक तरीके का उपयोग करता है: सूची में प्रत्येक स्ट्रिंग एक साथ प्रतिस्थापित करने का परिणाम है, पिछले स्ट्रिंग में "बी" के साथ "ए" की सभी घटनाएं और "बी" के साथ "बी" की सभी घटनाएं।

— ग्रेग मार्टिन
स्रोत

0

ग्रूवी, 79 बाइट्स

{println("a\nb");x=['a','b'];(it-2).times{println(y=x.sum());x[0]=x[1];x[1]=y}}

— जादू ऑक्टोपस Urn
स्रोत

0

PHP, 53 बाइट्स

for($a=b,$b=a;$argv[1]--;$a=($_=$b).$b=$a)echo$b.'
';

— चोकोचोस
स्रोत

डबल बट्स का उपयोग करके और $bस्ट्रिंग में डालकर एक बाइट बचाएं ।

— टाइटस

0

सी ++ 11, 89 98 बाइट्स

+7 सभी लाइनों के लिए बाइट्स , न केवल पिछले एक। +2 बाइट्स Nप्रिंट की गई लाइनों की संख्या के लिए अधिक है , कुछ 0-आधारित सामान नहीं।

#include<string>
using S=std::string;S f(int n,S a="a",S b="b"){return n-1?a+"\n"+f(n-1,b,a+b):a;}

उपयोग:

f(5)

— कार्ल नेफ
स्रोत

0

रूबी (1.9+) 46 बाइट्स

a,b=?a,?b;ARGV[0].to_i.times{puts a;a,b=b,a+b}

— shabunc
स्रोत

एक पत्र फिबोनाची प्रिंट करें

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

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

05AB1E , 12 11 बाइट्स

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

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

जावा 7, 69 बाइट्स

ungolfed

एमएसीएस, 26 , 25-ish कीस्ट्रोक्स

कार्यक्रम

व्याख्या

एन = 10 के साथ

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

CJam, 19 17 बाइट्स

वी , 18 बाइट्स

MATL , 14 बाइट्स

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

रेटिना , 33 बाइट्स

व्याख्या

बैच, 102 93 बाइट्स

मेरे गोल्फ को ढेर करो, 63 बाइट्स

पर्ल, 36 35 बाइट्स

पर्ल, 45 +1 = 46 बाइट्स

पर्ल, 42 बाइट्स

स्विफ्ट 3, 76 बाइट्स

पर्ल, 48 बाइट्स

प्रयोग

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

05AB1E, 15 बाइट्स

सी , 156 बाइट्स (इंडेंट के बिना)

PHP, 63 62 बाइट्स

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

पायथ - 16 15 बाइट्स

एपीएल, 30 बाइट्स।

मैथेमेटिका, 49 बाइट्स

मैथेमेटिका, 56 बाइट्स

ग्रूवी, 79 बाइट्स

PHP, 53 बाइट्स

सी ++ 11, 89 98 बाइट्स

रूबी (1.9+) 46 बाइट्स