Dato N (2 <= N ), stampa N righe della lettera serie Fibonacci in questo modo (cioè N = 5) Innanzitutto, inizia con ae b:

a
b

Quindi, aggiungi le due righe.

a
b
ab

Continua ad aggiungere le ultime due righe.

a
b
ab
bab

Continua così...

a
b
ab
bab
abbab

E abbiamo finito.

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

Python 2, 41 byte

Salvato 3 byte grazie a @xnor

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

Test su Ideone

Segue semplicemente la definizione ricorsiva.

Haskell, 29 35 32 byte

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

Ricorsione semplice.

Per riferimento: la vecchia versione (un adattamento di questa risposta ), concatenava le stringhe nell'ordine sbagliato, quindi ho dovuto aggiungere una flip(...)che la rendeva troppo lunga (35 byte).

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

05AB1E , 12 11 byte

Grazie a Emigna per aver salvato un byte!

'a='b¹GD=Š«

Utilizza la codifica CP-1252 . Provalo online!

Gelatina , 11 10 byte

”a”bṄ;¥@¡f

Provalo online!

Come funziona

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

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

}
}

Tasti Emacs, 26 , 25 ish

Programma

#nda leggere come chiave con le cifre n :

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

Spiegazione

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

Con n = 10

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab

JavaScript (ES6), 43 42 byte

Salvataggio di un byte grazie a @Arnauld

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

CJam, 19 17 byte

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

spiegazione

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

ia
bkÀñyjGpgJkñdj

Provalo online!

Oppure, la versione più leggibile:

ia
b<esc>kÀñyjGpgJkñdj

Spiegazione:

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 byte

97c98ci2-:"yyh

Provalo 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 byte

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

Retina , 33 byte

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

Provalo online!

Salvato 10 (!) Byte grazie a @ MartinEnder !

Spiegazione

Converte l'input in unario, sottrae 2e aggiunge e ae bquindi sostituisce ricorsivamente le rimanenti 1s con la concatenazione delle due stringhe precedenti.

Lotto, 102 93 byte

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

Fortunatamente le variabili vengono espanse per ogni riga prima che le assegnazioni abbiano effetto, quindi posso impostare entrambe ae busare i loro vecchi valori senza bisogno di un temporaneo. Modifica: salvato 9 byte grazie a @ nephi12.

Stack my Golf, 63 byte

Ottieni la mia lingua qui: https://github.com/cheertarts/Stack-My-Golf .

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

C'è probabilmente un modo più breve, ma questo è il più ovvio.

Perl, 36 35 byte

Include +3 per -n

Dai il conto su STDIN

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

fibo.pl

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

Perl, 45 +1 = 46 byte

+1 byte per -n flag

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

Leggero miglioramento rispetto alla soluzione a 49 byte esistente, ma sviluppato separatamente. Le parentesi say($a)sono necessarie perché altrimenti interpretano $a,($a,$b)=($b,$a.$b)come l'argomento di saycui genera più spazzatura del necessario.

Perl, 42 byte

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

Un approccio separato dalla soluzione sopra:

$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

Non sono ancora convinto di non poter combinare la traslitterazione e la sostituzione in un'unica operazione più breve. Se ne trovo uno, lo posterò.

Swift 3, 76 byte

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

Perl, 48 byte

47 byte codice + 1 per -n.

Approccio semplice Prova a utilizzare una porzione di array originariamente $a[@a]="@a[-2,-1]"ma ciò è necessario $"=""o simile :(. Risparmia 1 byte grazie a @ Dada !

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

uso

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

SOML , 8 byte (non concorrenti)

 a b.{;t⁴+

spiegazione:

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

Il motivo per cui questo non è in competizione è perché questo linguaggio è ancora in fase di sviluppo e ho aggiunto un paio di nuove funzioni mentre scrivevo questo.

Inoltre, 1 ° post su PPCG!

05AB1E, 15 byte

'a'bVUFX,XYUYJV

C , 156 byte (senza rientro)

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

Due buffer (u & v) memorizzano le ultime due righe. La riga più recente (tracciata con due puntatori: inizio = c, fine = d) viene aggiunta alla più vecchia (inizio = a, fine = b). Scambia (a, b) e (c, d) e loop. Prestare attenzione alla dimensione del buffer prima di richiedere troppe righe. Non così breve (come previsto da una lingua di basso livello), ma è stato divertente da programmare.

PHP, 63 62 byte

Versione ricorsiva:

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

Pyth , 17 byte

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

Un programma che accetta l'input di un numero intero e stampa il risultato.

Provalo online!

Come funziona

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 byte

A"ab" m=H+
~GHH

Provalo online qui .

APL, 30 byte.

⎕IOdeve essere 1.

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

Mathematica, 49 byte

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

Definisce una funzione che gaccetta il singolo input numerico; restituisce un elenco di stringhe. Implementazione ricorsiva semplice, usando l'operatore di string-join <>.

Mathematica, 56 byte

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

Funzione senza nome, stesso formato di input / output come sopra. Questa soluzione utilizza un modo alternativo per generare le stringhe: ogni stringa nell'elenco è il risultato della sostituzione simultanea, nella stringa precedente, di tutte le occorrenze di "a" con "b" e di tutte le occorrenze di "b" con "ab".

Groovy, 79 byte

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

PHP, 53 byte

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

C ++ 11, 89 98 byte

+7 byte per tutte le linee, non solo l'ultima. +2 byte in più per Nessere il numero di righe stampate, non alcune cose basate su 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;}

Uso:

f(5)

Ruby (1.9+) 46 byte

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