을 감안할 때 N (2 <= N ), 인쇄 N의 피보나치 시리즈이 (즉, 같은 문자의 라인 N = 5) 첫째, 시작 a과 b:

a
b

다음으로 두 줄을 추가하십시오.

a
b
ab

마지막 두 줄을 계속 추가하십시오.

a
b
ab
bab

계속 ...

a
b
ab
bab
abbab

그리고 우리는 끝났습니다.

기억하십시오, 이것은 code-golf 이므로 가장 적은 바이트를 가진 코드가 승리합니다.

파이썬 2, 41 바이트

@xnor 덕분에 3 바이트 절약

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

Ideone에서 테스트

재귀 적 정의를 따르기 만하면됩니다.

하스켈, 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.

자바 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);

}
}

이맥스, 26 , 25-ish 키 스트로크

프로그램

#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

자바 스크립트 (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

파이썬 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, 재귀 나머지 대신 1(S)은 이전의 두 스트링의 연결로.

배치, 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

아마도 더 짧은 방법이 있지만 이것이 가장 분명합니다.

펄, 36 35 바이트

에 +3 포함 -n

STDIN에 카운트

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

fibo.pl

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

펄, 45 +1 = 46 바이트

-n 플래그의 경우 +1 바이트

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

기존 49 바이트 솔루션에 비해 약간 개선되었지만 별도로 개발되었습니다. say($a)그렇지 않으면 괄호 가 필요합니다. 그렇지 않으면 필요한 것보다 더 많은 정크를 출력 $a,($a,$b)=($b,$a.$b)하는 인수로 해석 됩니다 say.

펄, 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)}}

펄, 48 바이트

47 바이트 코드 + 1 -n .

간단한 접근. 원래 배열 슬라이스를 사용해보십시오. $a[@a]="@a[-2,-1]"하지만 그 $"=""와 비슷하거나 비슷합니다 :(. @ Dada 덕분에 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단일 숫자 입력을받는 함수 를 정의합니다 . 문자열 목록을 반환합니다. 문자열 결합 연산자를 사용하여 간단한 재귀 구현<> .

매스 매 티카, 56 바이트

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

명명되지 않은 기능, 위와 동일한 입력 / 출력 형식. 이 솔루션은 대체 방법으로 문자열을 생성합니다. 목록의 각 문자열은 이전 문자열에서 "a"의 모든 발생을 "b"로, "b"의 모든 발생을 "ab"로 동시에 대체 한 결과입니다.

그루비, 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 바이트 . N0부터 시작하는 것이 아니라 인쇄 된 행 수로 2 바이트 이상 증가합니다 .

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