Учитывая N (2 <= N ), выведите N строк буквенного ряда Фибоначчи следующим образом (т.е. N = 5). Сначала начните с aи b:

a
b

Затем добавьте две строки.

a
b
ab

Продолжайте добавлять последние две строки.

a
b
ab
bab

Продолжай идти...

a
b
ab
bab
abbab

И мы сделали.

Remmeber, это код-гольф , поэтому выигрывает код с наименьшим количеством байтов.

Python 2, 41 байт

Сохранено 3 байта благодаря @xnor

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

Тест на идеоне

Просто следует рекурсивному определению.

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

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-и клавишные нажатия

программа

#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

Попробуйте онлайн!

Сохранено 10 (!) Байтов благодаря @ MartinEnder !

объяснение

Преобразует входные данные в унарные, вычитает 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использовать их старые значения, не требуя временных. Изменить: Сохранено 9 байтов благодаря @ nephi12.

Stack my Golf, 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

Я еще не уверен, что не смогу объединить транслитерацию и замену в одну более короткую операцию. Если я найду один, я отправлю это.

Swift 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 для -n.

Простой подход Попробуйте сначала использовать фрагмент массива, $a[@a]="@a[-2,-1]"но в этом есть необходимость $"=""или что-то подобное :(. Сохраните 1 байт благодаря @ Dada !

@;=(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"]

Причина, по которой это не конкурирует, заключается в том, что этот язык все еще находится в разработке, и я добавил несколько новых функций при написании этого.

Кроме того, 1-й пост на 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)

Рубин (1,9+) 46 байт

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