28
\$\begingroup\$

Given N (2 <= N), print N lines of the letter Fibonacci series like this (i.e. N = 5) First, start with a and b:

a
b

Next, add the two lines.

a
b
ab

Keep adding the last two lines.

a
b
ab
bab

Keep going...

a
b
ab
bab
abbab

And we're done.

Remmeber, this is , so the code with the fewest bytes wins.

| improve this question | | | | |
\$\endgroup\$
  • 4
    \$\begingroup\$ Related \$\endgroup\$ – AdmBorkBork Nov 3 '16 at 21:01
  • \$\begingroup\$ Can it be a function which returns a list of terms up to N? \$\endgroup\$ – FlipTack Nov 3 '16 at 21:21
  • \$\begingroup\$ Do we have to print the result or can we return a list of strings from a function? \$\endgroup\$ – nimi Nov 3 '16 at 21:21
  • \$\begingroup\$ Wait, so it doesn't have to work for n=1? \$\endgroup\$ – Socratic Phoenix Nov 3 '16 at 22:39
  • \$\begingroup\$ Also, can we use 0-based indexing? \$\endgroup\$ – Socratic Phoenix Nov 3 '16 at 22:45

39 Answers 39

10
\$\begingroup\$

Python 2, 41 bytes

Saved 3 bytes thanks to @xnor

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

Test on Ideone

Simply follows the recursive definition.

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ This is shorter as a program: a,b="ab";exec"print a;a,b=b,a+b;"*input(). \$\endgroup\$ – xnor Nov 3 '16 at 23:56
  • 1
    \$\begingroup\$ Might want to specify python 2 :) \$\endgroup\$ – FlipTack Nov 4 '16 at 7:47
8
\$\begingroup\$

Haskell, 29 35 32 bytes

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

Simple recursion.

For reference: the old version (an adaption of this answer), concatenated the strings in the wrong order, so I had to add a flip(...) which made it too long (35 bytes).

f="a":scanl(flip(++))"b"f
(`take`f)
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ The output is different from the example (different order in concatenation): ["b","a","ab","aba","abaab"] \$\endgroup\$ – Angs Nov 4 '16 at 5:57
  • \$\begingroup\$ @Angs: Oops what a mistake! Fixed. \$\endgroup\$ – nimi Nov 4 '16 at 6:18
6
\$\begingroup\$

05AB1E, 12 11 bytes

Thanks to Emigna for saving a byte!

'a='b¹GD=Š«

Uses the CP-1252 encoding. Try it online!

| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ ̓ could just as well be G as you're not using N :) \$\endgroup\$ – Emigna Nov 4 '16 at 7:18
  • \$\begingroup\$ @Emigna Oh yeah, you're right! Thanks :)! \$\endgroup\$ – Adnan Nov 4 '16 at 13:08
5
\$\begingroup\$

Jelly, 11 10 bytes

”a”bṄ;¥@¡f

Try it online!

How it works

”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.
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ I had the ”a”b;@Ṅ part down, but I couldn't figure out where to go from there... now I know :-) \$\endgroup\$ – ETHproductions Nov 4 '16 at 1:25
5
\$\begingroup\$

Java 7, 69 bytes

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

}
}
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ You really need to format your ungolfed code a bit more in your answers.. xD +1 though, and it even works for any other starting strings different than just a and b. I'm not sure if the "a" and "b" parameters should be counted towards the byte-count though, since the question specifically states it should use a and b. Not that Java will ever win anyway. ;) \$\endgroup\$ – Kevin Cruijssen Nov 4 '16 at 7:55
  • \$\begingroup\$ @KevinCruijssen the string parameters are required because their values change each time the method is invoked. \$\endgroup\$ – user18932 Nov 4 '16 at 13:59
  • \$\begingroup\$ @Snowman I know they are required.. I'm just saying that the byte-count should maybe be 75 bytes (+6 for "a" and "b") instead of 69 because the challenge specifically asked for a and b, and the code-snipped/method currently uses a variable input. Not sure what the rules are regarding something like this, but I personally think it should be counted. Otherwise you could in some languages have a function that executes a parameter function, and then simply give the entire challenge-function in the parameter without counting its bytes. Sounds like a standard-loophole type of rule. \$\endgroup\$ – Kevin Cruijssen Nov 4 '16 at 14:24
  • 1
    \$\begingroup\$ I love Java answers. They stand out so nice - 12 bytes here, 5 there, 17 here... 70 bytes there... wait, what? Oh, it's Java again... +1 \$\endgroup\$ – RudolfJelin Nov 4 '16 at 21:36
5
\$\begingroup\$

Emacs, 26, 25-ish keystrokes

Program

#n to be read as key with digit(s) n:

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

Explanation

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

With n=10

a
b
ab
bab
abbab
bababbab
abbabbababbab
bababbababbabbababbab
abbabbababbabbababbababbabbababbab
bababbababbabbababbababbabbababbabbababbababbabbababbab
| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ I'm torn. On one hand, I always upvote editor-golf, but on the other hand I use vim. Oh well, +1 anyway. :) \$\endgroup\$ – James Nov 4 '16 at 16:19
  • \$\begingroup\$ @DrMcMoylex just convert it to vim with C-u M-x convert-to-vim \$\endgroup\$ – YSC Nov 4 '16 at 17:12
5
\$\begingroup\$

JavaScript (ES6), 43 42 bytes

Saved a byte thanks to @Arnauld

f=(n,a="a",b="b")=>n&&f(n-!alert(a),b,a+b)
| improve this answer | | | | |
\$\endgroup\$
4
\$\begingroup\$

CJam, 19 17 bytes

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

explanation

"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
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ By the way, the number of strings is currently off by one; the last p should be a ;. You can get rid of the quotes around the output if you use n instead of p. Finally, 'a'b saves two bytes over "a""b". \$\endgroup\$ – Dennis Nov 4 '16 at 2:56
3
\$\begingroup\$

V, 18 bytes

ia
bkÀñyjGpgJkñdj

Try it online!

Or, the more readable version:

ia
b<esc>kÀñyjGpgJkñdj

Explanation:

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
| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

MATL, 14 bytes

97c98ci2-:"yyh

Try it 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
| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

Python 2, 55 bytes

def f(n):m='a','b';exec'print m[-2];m+=m[-2]+m[-1],;'*n
| improve this answer | | | | |
\$\endgroup\$
3
\$\begingroup\$

Retina, 33 bytes

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

Try it online!

Saved 10 (!) bytes thanks to @MartinEnder!

Explanation

Converts the input to unary, subtracts 2 and adds the a and the b, then recursively replaces the remaining 1s with the concatenation of the two previous strings.

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ Saved a few bytes by avoiding unnecessary captures: retina.tryitonline.net/… \$\endgroup\$ – Martin Ender Nov 5 '16 at 0:15
  • \$\begingroup\$ @MartinEnder Nice! Didn't quite see the power of $%` ! and that other capture was just bad planning... Amazing, thank you! \$\endgroup\$ – Dom Hastings Nov 5 '16 at 10:12
2
\$\begingroup\$

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

Fortunately variables are expanded for every line before assignments take effect, so I can set both a and b using their old values without needing a temporary. Edit: Saved 9 bytes thanks to @nephi12.

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ I was about to do this ;) By the way, you can save 8 bytes by removing the "exit/b" and starting your loop from 2: for /l %%i in (2,1,%1) etc.. \$\endgroup\$ – nephi12 Nov 4 '16 at 0:41
  • \$\begingroup\$ One more (the newline) by putting the set commands on the same line @set a=a&set b=b like you did with the last one. though techncally they could all be on the same line... but that would be ugly... hmm... \$\endgroup\$ – nephi12 Nov 4 '16 at 0:48
2
\$\begingroup\$

Stack my Golf, 63 bytes

Get my language here: https://github.com/cheertarts/Stack-My-Golf.

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

There is probably a shorter way but this is the most obvious.

| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Perl, 36 35 bytes

Includes +3 for -n

Give count on STDIN

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

fibo.pl

#!/usr/bin/perl -n
$_=$'.s/1//.$_,say$`for(a1.b)x$_
| improve this answer | | | | |
\$\endgroup\$
2
\$\begingroup\$

Perl, 45 +1 = 46 bytes

+1 byte for -n flag

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

Slight improvement over the existing 49-byte solution, but developed separately. The parentheses for say($a) are necessary because otherwise, it interprets $a,($a,$b)=($b,$a.$b) as the argument of say which outputs more junk than we need.

Perl, 42 bytes

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

A separate approach from the above solution:

$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

I'm not yet convinced I can't combine the transliteration and replacement into a single, shorter operation. If I find one, I'll post it.

| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

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)}}
| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

Perl, 48 bytes

47 bytes code + 1 for -n.

Simple approach. Try using an array slice originally $a[@a]="@a[-2,-1]" but that necessitates $"="" or similar :(. Save 1 byte thanks to @Dada!

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

Usage

perl -nE '@;=(a,b);$;[@;]=$;[-2].$;[-1]for 3..$_;say for@' <<< 5
a
b
ab
bab
abbab
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ You can save one byte by using @; instead of @a so you can omit the final semicolon (see what I mean?). (I know, one byte is pretty cheap but I didn't have any better idea..) \$\endgroup\$ – Dada Nov 4 '16 at 13:46
  • \$\begingroup\$ @Dada Yeah, I tried that, but it wound't compile on my machine, so I thought perhaps there's something odd going on with mine: perl -pe '@;=(a,b);$;[@;]=$;[-2].$;[-1]for 3..$_;say for@' <<< 5 syntax error at -e line 1, at EOF Execution of -e aborted due to compilation errors. but didn't think it'd be fair to add as an answer if I couldn't get it working! \$\endgroup\$ – Dom Hastings Nov 4 '16 at 13:50
  • \$\begingroup\$ Sure this isn't related to the -pe instead of -nE ? Any way, it works on mine, so it's probably related to your perl version or system... But trust me, I tested it and it works! ;) \$\endgroup\$ – Dada Nov 4 '16 at 13:53
  • \$\begingroup\$ @Dada I get the same with -nE as well (don't know where -pe came from! Must be Friday...) I'll update that when I get a mo! Thanks for sharing! \$\endgroup\$ – Dom Hastings Nov 4 '16 at 13:57
1
\$\begingroup\$

SOML, 8 bytes (non-competing)

 a b.{;t⁴+

explanation:

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

The reason this is non-competing is because this language is still in development and I did add a couple new functions while writing this.

Also, 1st post on PPCG!

| improve this answer | | | | |
\$\endgroup\$
  • 1
    \$\begingroup\$ Welcome to PPCG! Great first post! \$\endgroup\$ – Oliver Ni Nov 6 '16 at 15:21
1
\$\begingroup\$

05AB1E, 15 bytes

'a'bVUFX,XYUYJV
| improve this answer | | | | |
\$\endgroup\$
1
\$\begingroup\$

C, 156 bytes (without indent)

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

Two buffers (u & v) store the last two lines. The newest line (tracked with two pointers: start=c, end=d) is appended to the oldest one (start=a, end=b). Swap (a,b) and (c,d), and loop. Pay attention to buffer size before requesting too much lines. Not so short (as expected of a low-level language), but was fun to code.

| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ You hardcoded the 5 but it should be user input \$\endgroup\$ – Karl Napf Nov 4 '16 at 16:10
  • \$\begingroup\$ Hmm... I do not see "user input" as a requirement in the puzzle... Following the same path as Perl, Python, C++, ... answers, replace "int main()" with "void f(int n)". \$\endgroup\$ – Phil Nov 4 '16 at 16:56
  • \$\begingroup\$ Given N (2 <= N), print N lines of the letter Fibonacci series like this (i.e. N = 5) \$\endgroup\$ – Karl Napf Nov 4 '16 at 19:02
  • \$\begingroup\$ Well, user input was a bad choice in term of words. I meant more like dynamic N and not fixed. Or the user might be somebody who uses your function/program. \$\endgroup\$ – Karl Napf Nov 4 '16 at 19:03
  • \$\begingroup\$ I've corrected a stupid mistake about not copying the nul terminator. I've also put the function in a more readable state (one liners are funny, but not handy). To actually test this function, use this : int main(int n, char**p){f(n<2?5:atoi(p[1]));return 0;} \$\endgroup\$ – Phil Nov 7 '16 at 12:43
1
\$\begingroup\$

PHP, 63 62 bytes

Recursive version:

function f($n,$a=a,$b=b){return$n--?"$a
".f($n,$b,$a.$b):'';}
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ unnecessary whitespace after return \$\endgroup\$ – Titus Nov 11 '16 at 15:49
0
\$\begingroup\$

Pyth, 17 bytes

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

A program that takes input of an integer and prints the result.

Try it online!

How it works

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
| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

Pyth - 16 15 bytes

A"ab" m=H+
~GHH

Try it online here.

| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

APL, 30 bytes.

⎕IO must be 1.

{⎕←⍵}¨{⍵∊⍳2:⍵⌷'ab'⋄∊∇¨⍵-⌽⍳2}¨⍳
| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

Mathematica, 49 bytes

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

Defines a function g taking the single numerical input; returns a list of strings. Straightforward recursive implementation, using the string-joining operator <>.

Mathematica, 56 bytes

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

Unnamed function, same input/output format as above. This solution uses an alternate way to generate the strings: each string in the list is the result of simultaneously replacing, in the previous string, all occurrences of "a" with "b" and all occurrences of "b" with "ab".

| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

Groovy, 79 Bytes

{println("a\nb");x=['a','b'];(it-2).times{println(y=x.sum());x[0]=x[1];x[1]=y}}
| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

PHP, 53 bytes

for($a=b,$b=a;$argv[1]--;$a=($_=$b).$b=$a)echo$b.'
';
| improve this answer | | | | |
\$\endgroup\$
  • \$\begingroup\$ save one byte by using double quotes and putting $b in the string. \$\endgroup\$ – Titus Nov 11 '16 at 15:48
0
\$\begingroup\$

C++11, 89 98 bytes

+7 bytes for all lines, not only the last one. +2 bytes more for N being the number of lines printed, not some 0-based stuff.

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

Usage:

f(5)
| improve this answer | | | | |
\$\endgroup\$
0
\$\begingroup\$

Ruby (1.9+) 46 bytes

a,b=?a,?b;ARGV[0].to_i.times{puts a;a,b=b,a+b}
| improve this answer | | | | |
\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.