Étant donné N (2 <= N ), imprimez N lignes de la série des lettres Fibonacci comme ceci (c.-à-d. N = 5) Commencez par aet b:

a
b

Ensuite, ajoutez les deux lignes.

a
b
ab

Continuez à ajouter les deux dernières lignes.

a
b
ab
bab

Continue...

a
b
ab
bab
abbab

Et nous avons terminé.

Rappelez-vous, c'est le code-golf , donc le code avec le moins d'octets gagne.

Python 2, 41 octets

Enregistré 3 octets grâce à @xnor

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

Test sur Ideone

Suit simplement la définition récursive.

Haskell, 29 35 32 octets

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

Récursivité simple.

Pour référence: l'ancienne version (une adaptation de cette réponse ), concaténait les chaînes dans le mauvais ordre, j'ai donc dû en ajouter une flip(...)qui la rendait trop longue (35 octets).

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

05AB1E , 12 11 octets

Merci à Emigna d' avoir sauvé un octet!

'a='b¹GD=Š«

Utilise l' encodage CP-1252 . Essayez-le en ligne!

Gelée , 11 10 octets

”a”bṄ;¥@¡f

Essayez-le en ligne!

Comment ça marche

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

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

non golfé

 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 touches

Programme

#nà lire comme clé avec chiffre (s) n :

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

Explication

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

Avec n = 10

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab

JavaScript (ES6), 43 42 octets

Un octet enregistré grâce à @Arnauld

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

CJam, 19 17 octets

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

explication

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

ia
bkÀñyjGpgJkñdj

Essayez-le en ligne!

Ou, la version la plus lisible:

ia
b<esc>kÀñyjGpgJkñdj

Explication:

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 octets

97c98ci2-:"yyh

Essayez-le en ligne!

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 octets

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

Rétine , 33 octets

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

Essayez-le en ligne!

10 (!) Octets enregistrés grâce à @ MartinEnder !

Explication

Convertit l'entrée en unaire, soustrait 2et ajoute le aet le b, puis remplace récursivement les 1s restants par la concaténation des deux chaînes précédentes.

Lot, 102 93 octets

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

Heureusement, les variables sont développées pour chaque ligne avant que les affectations ne prennent effet, donc je peux définir les deux aet butiliser leurs anciennes valeurs sans avoir besoin d'un temporaire. Edit: 9 octets enregistrés grâce à @ nephi12.

Stack my Golf, 63 octets

Obtenez ma langue ici: https://github.com/cheertarts/Stack-My-Golf .

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

Il y a probablement un chemin plus court mais c'est le plus évident.

Perl, 36 35 octets

Comprend +3 pour -n

Comptez sur STDIN

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

fibo.pl

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

Perl, 45 +1 = 46 octets

+1 octet pour l'indicateur -n

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

Légère amélioration par rapport à la solution existante de 49 octets, mais développée séparément. Les parenthèses poursay($a) sont nécessaires car sinon, il interprète $a,($a,$b)=($b,$a.$b)comme l'argument desay qui génère plus d'ordure que nécessaire.

Perl, 42 octets

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

Une approche distincte de la solution ci-dessus:

$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

Je ne suis pas encore convaincu que je ne peux pas combiner la translittération et le remplacement en une seule opération plus courte. Si j'en trouve un, je le posterai.

Swift 3, 76 octets

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

Perl, 48 octets

Code de 47 octets + 1 pour -n .

Une approche simple. Essayez d'utiliser une tranche de tableau à l'origine $a[@a]="@a[-2,-1]"mais cela nécessite $"=""ou similaire :(. Économisez 1 octet grâce à @ Dada !

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

Usage

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

SOML , 8 octets (non concurrent)

 a b.{;t⁴+

explication:

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

La raison pour laquelle il n'y a pas de concurrence est que ce langage est toujours en développement et j'ai ajouté quelques nouvelles fonctions lors de l'écriture.

Aussi, 1er post sur PPCG!

05AB1E, 15 octets

'a'bVUFX,XYUYJV

C , 156 octets (sans retrait)

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

Deux tampons (u & v) stockent les deux dernières lignes. La ligne la plus récente (suivie avec deux pointeurs: début = c, fin = d) est ajoutée à la plus ancienne (début = a, fin = b). Permutez (a, b) et (c, d) et bouclez. Faites attention à la taille du tampon avant de demander trop de lignes. Pas si court (comme prévu pour un langage de bas niveau), mais c'était amusant à coder.

PHP, 63 62 octets

Version récursive:

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

Pyth , 17 octets

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

Un programme qui prend l'entrée d'un entier et imprime le résultat.

Essayez-le en ligne!

Comment ça marche

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 octets

A"ab" m=H+
~GHH

Essayez-le en ligne ici .

APL, 30 octets.

⎕IOdoit être 1.

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

Mathematica, 49 octets

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

Définit une fonction gprenant la seule entrée numérique; renvoie une liste de chaînes. Implémentation récursive simple à l'aide de l'opérateur de jonction de chaînes<> .

Mathematica, 56 octets

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

Fonction sans nom, même format d'entrée / sortie que ci-dessus. Cette solution utilise une autre manière de générer les chaînes: chaque chaîne de la liste est le résultat du remplacement simultané, dans la chaîne précédente, de toutes les occurrences de "a" par "b" et de toutes les occurrences de "b" par "ab".

Groovy, 79 octets

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

PHP, 53 octets

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

C++11, 89 98 bytes

+7 bytes for all lines, not only the last one. +2 bytes more for N being the number of lines printed, not some 0-based stuff.

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

Usage:

f(5)

Ruby (1.9+) 46 bytes

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