给定N（2 <= N），按如下方式打印字母Fibonacci系列的N行（即N = 5）首先，从a和开始b：

a
b

接下来，添加两行。

a
b
ab

继续添加最后两行。

a
b
ab
bab

继续...

a
b
ab
bab
abbab

我们完成了。

提醒，这是code-golf，所以字节最少的代码将获胜。

Python 2，41个字节

@xnor节省了3个字节

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

测试Ideone

只需遵循递归定义。

Haskell，29 35 32字节

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

简单递归。

供参考：旧版本（此答案的变体）以错误的顺序连接了字符串，因此我必须添加一个flip(...)使其过长（35字节）的字符串。

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

05AB1E，12 11字节

感谢Emigna节省了一个字节！

'a='b¹GD=Š«

使用CP-1252编码。在线尝试！

果冻， 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.

Java 7，69字节

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

不打高尔夫球

 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上下的按键

程序

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

n = 10

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab

JavaScript（ES6），43 42字节

感谢@Arnauld，节省了一个字节

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

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

V，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

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

Python 2，55个字节

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

视网膜，33字节

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

在线尝试！

由于@ MartinEnder，节省了10（！）个字节！

说明

输入转换为一元，减去2并添加a和b，然后递归替换剩余1s的前两个字符串的连接。

批次，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使用其旧值而无需临时设置。编辑：由于@ nephi12，节省了9个字节。

堆我的高尔夫球，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

可能有更短的方法，但这是最明显的。

Perl，36 35字节

包括+3 -n

指望STDIN

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

fibo.pl

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

Perl，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输出比我们需要更多的垃圾的参数。

Perl，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

我还不确定我不能将音译和替换合并为一个更短的操作。如果找到一个，我将其发布。

迅捷3，76字节

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

Perl，48个字节

47个字节的代码+ 1 for -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

SOML，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的第一篇文章！

05AB1E，15个字节

'a'bVUFX,XYUYJV

C，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）存储最后两行。最新的行（使用两个指针跟踪：start = c，end = d）被追加到最旧的行（start = a，end = b）。交换（a，b）和（c，d），然后循环。请求过多行之前，请注意缓冲区大小。不够短（不像一种低级语言所期望的那样），但是编写代码很有趣。

PHP，63 62字节

递归版本：

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

Pyth，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

Pyth- 16 15字节

A"ab" m=H+
~GHH

在这里在线尝试。

APL，30个字节。

⎕IO必须是1。

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

Mathematica，49个字节

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

定义一个函数g以单个数字输入；返回字符串列表。使用字符串连接运算符的简单递归实现<>。

Mathematica，56个字节

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

未命名的函数，与上面相同的输入/输出格式。此解决方案使用另一种方式来生成字符串：列表中的每个字符串都是在前一个字符串中同时将所有出现的“ a”替换为“ b”以及所有出现的“ b”替换为“ ab”的结果。

Groovy，79字节

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

PHP，53字节

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

C ++ 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)

Ruby（1.9+）46字节

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