Mit N (2 <= N ) drucken Sie N Zeilen der Buchstaben-Fibonacci-Reihe wie folgt (dh N = 5). Beginnen Sie zuerst mit aund b:

a
b

Fügen Sie als Nächstes die beiden Zeilen hinzu.

a
b
ab

Fügen Sie die letzten beiden Zeilen hinzu.

a
b
ab
bab

Mach weiter...

a
b
ab
bab
abbab

Und wir sind fertig.

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

Python 2, 41 Bytes

3 Bytes dank @xnor gespart

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

Test auf Ideone

Folgt einfach der rekursiven Definition.

Haskell, 29 35 32 Bytes

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

Einfache Rekursion.

Als Referenz: Die alte Version (eine Anpassung dieser Antwort ) verkettete die Zeichenfolgen in der falschen Reihenfolge, so dass ich eine hinzufügen musste, flip(...)die es zu lang machte (35 Bytes).

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

05AB1E , 12 11 Bytes

Danke an Emigna für das Speichern eines Bytes!

'a='b¹GD=Š«

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Jelly , 11 bis 10 Bytes

”a”bṄ;¥@¡f

Probieren Sie es online!

Wie es funktioniert

”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.

Java 7, 69 Bytes

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

}
}

Emacs, 26 , 25-ish Tastenanschläge

Programm

#nLesen als Schlüssel mit Ziffer (n) werden n :

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

Erläuterung

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

Mit n = 10

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab

JavaScript (ES6), 43 42 Bytes

Ein Byte dank @Arnauld gespeichert

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

CJam, 19 17 Bytes

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

Erläuterung

"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

V , 18 Bytes

ia
bkÀñyjGpgJkñdj

Probieren Sie es online!

Oder die besser lesbare Version:

ia
b<esc>kÀñyjGpgJkñdj

Erläuterung:

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

MATL , 14 Bytes

97c98ci2-:"yyh

Probieren Sie es online!

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

Python 2, 55 Bytes

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

Retina , 33 Bytes

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

Probieren Sie es online!

10 (!) Bytes gespart dank @ MartinEnder !

Erläuterung

Konvertiert die Eingabe in unär, subtrahiert 2und addiert das aund und bersetzt dann rekursiv das verbleibende 1s durch die Verkettung der beiden vorherigen Zeichenfolgen.

Batch, 102 93 Bytes

@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%

Zum Glück Variablen werden für jede Zeile erweitert , bevor Zuweisungen wirksam, so dass ich beide setzen können aund bmit ihren alten Werten , ohne dass eine temporäre. Bearbeiten: 9 Bytes dank @ nephi12 gespeichert.

Staple meinen Golf, 63 Bytes

Meine Sprache finden Sie hier: https://github.com/cheertarts/Stack-My-Golf .

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

Es gibt wahrscheinlich einen kürzeren Weg, aber dieser ist der offensichtlichste.

Perl, 36-35 Bytes

Beinhaltet +3 für -n

Rechnen Sie mit STDIN

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

fibo.pl

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

Perl, 45 +1 = 46 Bytes

+1 Byte für -n Flag

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

Leichte Verbesserung gegenüber der bestehenden 49-Byte-Lösung, wurde jedoch separat entwickelt. Die Klammern für say($a)sind notwendig, da sie andernfalls $a,($a,$b)=($b,$a.$b)als Argument interpretiert werden, das saymehr Junk ausgibt, als wir benötigen.

Perl, 42 Bytes

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

Ein separater Ansatz von der obigen Lösung:

$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

Ich bin noch nicht davon überzeugt, dass ich Transliteration und Ersetzung nicht in einer einzigen, kürzeren Operation kombinieren kann. Wenn ich einen finde, werde ich ihn posten.

Schnelle 3, 76 Bytes

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

Perl, 48 Bytes

47 Byte Code + 1 für -n .

Einfacher Ansatz. Versuchen Sie ursprünglich $a[@a]="@a[-2,-1]", ein Array-Slice zu verwenden, aber das erfordert $"=""oder ähnliches :(. 1 Byte sparen dank @ Dada !

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

Verwendung

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

SOML , 8 Bytes (nicht konkurrierend)

 a b.{;t⁴+

Erläuterung:

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

Der Grund, warum dies nicht konkurriert, ist, dass sich diese Sprache noch in der Entwicklung befindet und ich beim Schreiben ein paar neue Funktionen hinzugefügt habe.

Auch 1. Post auf PPCG!

05AB1E, 15 Bytes

'a'bVUFX,XYUYJV

C , 156 Bytes (ohne Einzug)

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

Zwei Puffer (u & v) speichern die letzten beiden Zeilen. Die neueste Zeile (mit zwei Zeigern verfolgt: Start = c, Ende = d) wird an die älteste angefügt (Start = a, Ende = b). Vertausche (a, b) und (c, d) und schleife. Achten Sie auf die Puffergröße, bevor Sie zu viele Zeilen anfordern. Nicht so kurz (wie von einer einfachen Sprache erwartet), aber es hat Spaß gemacht, zu programmieren.

PHP, 63 62 Bytes

Rekursive Version:

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

Pyth , 17 Bytes

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

Ein Programm, das die Eingabe einer Ganzzahl akzeptiert und das Ergebnis ausgibt.

Probieren Sie es online!

Wie es funktioniert

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

Pyth - 16 15 Bytes

A"ab" m=H+
~GHH

Probieren Sie es hier online aus .

APL, 30 Bytes.

⎕IOmuss sein 1.

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

Mathematica, 49 Bytes

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

Definiert eine Funktion, gdie die einzelne numerische Eingabe übernimmt. gibt eine Liste von Zeichenketten zurück. Einfache rekursive Implementierung mit dem Operator zum Verbinden von Zeichenfolgen<> .

Mathematica, 56 Bytes

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

Unbenannte Funktion, gleiches Eingabe- / Ausgabeformat wie oben. Diese Lösung verwendet eine alternative Methode zum Generieren der Zeichenfolgen: Jede Zeichenfolge in der Liste ist das Ergebnis des gleichzeitigen Ersetzens aller Vorkommen von "a" durch "b" und aller Vorkommen von "b" durch "ab" in der vorherigen Zeichenfolge.

Groovy, 79 Bytes

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

PHP, 53 Bytes

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

C ++ 11, 89 98 Bytes

+7 Bytes für alle Zeilen, nicht nur die letzte. +2 Bytes mehr für Ndie Anzahl der gedruckten Zeilen, keine 0-basierten Sachen.

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

Verwendung:

f(5)

Ruby (1.9+) 46 Bytes

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