Biorąc pod uwagę N (2 <= N ), wypisz N wierszy z serii liter Fibonacciego w ten sposób (tj. N = 5) Najpierw zacznij od ai b:

a
b

Następnie dodaj dwie linie.

a
b
ab

Dodawaj dwa ostatnie wiersze.

a
b
ab
bab

Tak trzymaj...

a
b
ab
bab
abbab

I skończyliśmy.

Pamiętaj, to jest golf golfowy , więc wygrywa kod z najmniejszą liczbą bajtów.

Python 2, 41 bajtów

Zaoszczędź 3 bajty dzięki @xnor

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

Testuj na Ideone

Po prostu podąża za rekurencyjną definicją.

Haskell, 29 35 32 bajtów

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

Prosta rekurencja.

Dla porównania: stara wersja (adaptacja tej odpowiedzi ) połączyła łańcuchy w niewłaściwej kolejności, więc musiałem dodać wartość, flip(...)która spowodowała, że ​​była za długa (35 bajtów).

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

05AB1E , 12 11 bajtów

Dzięki Emignie za uratowanie bajtu!

'a='b¹GD=Š«

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Galaretka , 11 10 bajtów

”a”bṄ;¥@¡f

Wypróbuj online!

Jak to działa

”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 bajtów

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

bez golfa

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

Program

#nnależy czytać jako klucz z cyframi (cyframi) n :

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

Wyjaśnienie

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

Przy n = 10

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab

JavaScript (ES6), 43 42 bajty

Zapisano bajt dzięki @Arnauld

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

CJam, 19 17 bajtów

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

wyjaśnienie

"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 bajtów

ia
bkÀñyjGpgJkñdj

Wypróbuj online!

Lub bardziej czytelna wersja:

ia
b<esc>kÀñyjGpgJkñdj

Wyjaśnienie:

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 bajtów

97c98ci2-:"yyh

Wypróbuj 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 bajtów

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

Siatkówka , 33 bajty

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

Wypróbuj online!

Zaoszczędź 10 (!) Bajtów dzięki @ MartinEnder !

Wyjaśnienie

Konwertuje dane wejściowe na jednoargumentowe, odejmuje 2i dodaje ai b, a następnie rekurencyjnie zastępuje pozostałe 1s łączeniem dwóch poprzednich ciągów.

Partia, 102 93 bajty

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

Na szczęście zmienne są rozwijane dla każdej linii, zanim przypisania zaczną obowiązywać, więc mogę ustawić obie ai bużywać ich starych wartości bez potrzeby tymczasowego. Edycja: Zapisano 9 bajtów dzięki @ nephi12.

Stack my Golf, 63 bajty

Pobierz mój język tutaj: https://github.com/cheertarts/Stack-My-Golf .

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

Prawdopodobnie jest krótsza droga, ale jest to najbardziej oczywista.

Perl, 36 35 bajtów

Obejmuje +3 za -n

Policz na STDIN

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

fibo.pl

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

Perl, 45 +1 = 46 bajtów

+1 bajt dla flagi -n

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

Niewielka poprawa w stosunku do istniejącego 49-bajtowego rozwiązania, ale opracowana osobno. Nawiasy dla say($a)są konieczne, ponieważ w przeciwnym razie interpretuje to $a,($a,$b)=($b,$a.$b)jako argument, sayktórego wynikiem jest więcej śmieci niż potrzebujemy.

Perl, 42 bajty

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

Oddzielne podejście od powyższego rozwiązania:

$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

Nie jestem jeszcze przekonany, że nie mogę połączyć transliteracji i zamiany w jedną krótszą operację. Jeśli go znajdę, opublikuję go.

Swift 3, 76 bajtów

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

Perl, 48 bajtów

47 bajtów kod + 1 dla -n.

Proste podejście. Spróbuj użyć fragmentu tablicy pierwotnie, $a[@a]="@a[-2,-1]"ale to wymaga $"=""lub jest podobne :(. Oszczędź 1 bajt dzięki @ Dada !

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

Stosowanie

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

SOML , 8 bajtów (niekonkurencyjny)

 a b.{;t⁴+

wyjaśnienie:

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

Powodem, dla którego nie jest konkurencyjny, jest to, że ten język jest wciąż w fazie rozwoju i podczas pisania tego dodałem kilka nowych funkcji.

Również pierwszy post na PPCG!

05AB1E, 15 bajtów

'a'bVUFX,XYUYJV

C , 156 bajtów (bez wcięcia)

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

Dwa bufory (u & v) przechowują ostatnie dwa wiersze. Najnowsza linia (śledzona za pomocą dwóch wskaźników: start = c, end = d) jest dołączana do najstarszej (start = a, end = b). Zamień (a, b) i (c, d) i zapętl. Zwróć uwagę na rozmiar bufora przed zażądaniem zbyt dużej liczby linii. Nie tak krótki (jak można się spodziewać po języku niskiego poziomu), ale dobrze się bawił.

PHP, 63 62 bajty

Wersja rekurencyjna:

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

Pyth , 17 bajtów

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

Program, który pobiera liczbę całkowitą i wypisuje wynik.

Wypróbuj online!

Jak to działa

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 bajtów

A"ab" m=H+
~GHH

Wypróbuj online tutaj .

APL, 30 bajtów.

⎕IOmusi być 1.

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

Mathematica, 49 bajtów

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

Definiuje funkcję gprzyjmującą pojedyncze dane liczbowe; zwraca listę ciągów znaków. Prosta implementacja rekurencyjna za pomocą operatora łączenia ciągów <>.

Mathematica, 56 bajtów

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

Funkcja bez nazwy, taki sam format wejścia / wyjścia jak powyżej. To rozwiązanie wykorzystuje alternatywny sposób generowania ciągów: każdy ciąg na liście jest wynikiem jednoczesnego zastąpienia, w poprzednim ciągu, wszystkich wystąpień „a” na „b” i wszystkich wystąpień „b” na „ab”.

Groovy, 79 bajtów

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

PHP, 53 bajty

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

C ++ 11, 89 98 bajtów

+7 bajtów dla wszystkich linii, nie tylko ostatniej. +2 bajty więcej za Nliczbę wydrukowanych linii, a nie niektóre rzeczy oparte na 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;}

Stosowanie:

f(5)

Rubinowy (1.9+) 46 bajtów

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