Dado N (2 <= N ), imprima N líneas de la serie de letras de Fibonacci como esta (es decir, N = 5) Primero, comience con ay b:

a
b

Luego, agregue las dos líneas.

a
b
ab

Sigue agregando las dos últimas líneas.

a
b
ab
bab

Sigue adelante...

a
b
ab
bab
abbab

Y ya hemos terminado.

Recuerda, este es el código de golf , por lo que gana el código con la menor cantidad de bytes.

Python 2, 41 bytes

Guardado 3 bytes gracias a @xnor

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

Prueba de ideona

Simplemente sigue la definición recursiva.

Haskell, 29 35 32 bytes

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

Recurrencia simple

Como referencia: la versión anterior (una adaptación de esta respuesta ) concatenaba las cadenas en el orden incorrecto, así que tuve que agregar una flip(...)que la hizo demasiado larga (35 bytes).

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

05AB1E , 12 11 bytes

¡Gracias a Emigna por guardar un byte!

'a='b¹GD=Š«

Utiliza la codificación CP-1252 . Pruébalo en línea!

Jalea , 11 10 bytes

”a”bṄ;¥@¡f

Pruébalo en línea!

Cómo funciona

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

sin 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 pulsaciones de teclas

Programa

#npara ser leído como clave con dígitos (s) n :

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

Explicación

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 bytes

Guardado un byte gracias a @Arnauld

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

CJam, 19 17 bytes

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

explicación

"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

Pruébalo en línea!

O, la versión más legible:

ia
b<esc>kÀñyjGpgJkñdj

Explicación:

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

Pruébalo en línea!

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

Pruébalo en línea!

¡ Ahorró 10 (!) Bytes gracias a @ MartinEnder !

Explicación

Convierte la entrada en unario, resta 2y suma el ay el b, luego reemplaza recursivamente los 1s restantes con la concatenación de las dos cadenas anteriores.

Lote, 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%

Afortunadamente, las variables se expanden para cada línea antes de que las asignaciones surtan efecto, por lo que puedo establecer ambas ay busar sus valores anteriores sin necesidad de una temporal. Editar: Guardado 9 bytes gracias a @ nephi12.

Apila mi golf, 63 bytes

Obtenga mi idioma aquí: https://github.com/cheertarts/Stack-My-Golf .

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

Probablemente haya un camino más corto, pero este es el más obvio.

Perl, 36 35 bytes

Incluye +3 para -n

Dar cuenta de 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 para la bandera -n

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

Ligera mejora sobre la solución existente de 49 bytes, pero desarrollada por separado. Los paréntesis parasay($a) son necesarios porque, de lo contrario, se interpreta $a,($a,$b)=($b,$a.$b)como el argumento de sayque genera más basura de la que necesitamos.

Perl, 42 bytes

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

Un enfoque separado de la solución anterior:

$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

Todavía no estoy convencido de que no pueda combinar la transliteración y el reemplazo en una sola operación más corta. Si encuentro uno, lo publicaré.

Swift 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

Código de 47 bytes + 1 para -n .

Enfoque simple Intente usar un segmento de matriz originalmente, $a[@a]="@a[-2,-1]"pero eso requiere $"=""o similar :(. ¡Ahorre 1 byte gracias 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 bytes (no competitivos)

 a b.{;t⁴+

explicación:

 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 razón por la que esto no compite es porque este lenguaje todavía está en desarrollo y agregué un par de nuevas funciones mientras escribía esto.

Además, 1er post en PPCG!

05AB1E, 15 bytes

'a'bVUFX,XYUYJV

C , 156 bytes (sin sangría)

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

Dos buffers (u & v) almacenan las dos últimas líneas. La línea más nueva (seguida con dos punteros: inicio = c, final = d) se agrega a la más antigua (inicio = a, final = b). Intercambiar (a, b) y (c, d) y bucle. Preste atención al tamaño del búfer antes de solicitar demasiadas líneas. No tan corto (como se esperaba de un lenguaje de bajo nivel), pero fue divertido de codificar.

PHP, 63 62 bytes

Versión recursiva:

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

Pyth , 17 bytes

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

Un programa que toma la entrada de un número entero e imprime el resultado.

Pruébalo en línea!

Cómo funciona

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

Pruébelo en línea aquí .

APL, 30 bytes.

⎕IOdebe ser 1.

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

Mathematica, 49 bytes

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

Define una función que gtoma la entrada numérica única; devuelve una lista de cadenas. Implementación recursiva directa, utilizando el operador de unión de cadenas<> .

Mathematica, 56 bytes

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

Función sin nombre, mismo formato de entrada / salida que el anterior. Esta solución utiliza una forma alternativa de generar las cadenas: cada cadena de la lista es el resultado de reemplazar simultáneamente, en la cadena anterior, todas las apariciones de "a" con "b" y todas las apariciones de "b" con "ab".

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 para todas las líneas, no solo la última. +2 bytes más por Nser el número de líneas impresas, no algunas cosas basadas en 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 bytes

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