# Fibonacci function or sequence

The Fibonacci sequence is a sequence of numbers, where every number in the sequence is the sum of the two numbers preceding it. The first two numbers in the sequence are both 1.

Here are the first few terms

1 1 2 3 5 8 13 21 34 55 89 ...


Write the shortest code that either:

• Generates the Fibonacci sequence without end.

• Given n calculates the nth term of the sequence. (Either 1 or zero indexed)

You may use standard forms of input and output.

(I gave both options in case one is easier to do in your chosen language than the other.)

For the function that takes an n, a reasonably large return value (the largest Fibonacci number that fits your computer's normal word size, at a minimum) has to be supported.

/* Configuration */

var QUESTION_ID = 85; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 3; // This should be the user ID of the challenge author.

/* App */

return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(a) {
});
comment_page = 1;
}
});
}

jQuery.ajax({
method: "get",
dataType: "jsonp",
crossDomain: true,
success: function (data) {
data.items.forEach(function(c) {
if (c.owner.user_id === OVERRIDE_USER)
});
else process();
}
});
}

var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

function getAuthorName(a) {
return a.owner.display_name;
}

function process() {
var valid = [];

var body = a.body;
if(OVERRIDE_REG.test(c.body))
body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
});

var match = body.match(SCORE_REG);
if (match)
valid.push({
user: getAuthorName(a),
size: +match[2],
language: match[1],
});
else console.log(body);
});

valid.sort(function (a, b) {
var aB = a.size,
bB = b.size;
return aB - bB
});

var languages = {};
var place = 1;
var lastSize = null;
var lastPlace = 1;
valid.forEach(function (a) {
if (a.size != lastSize)
lastPlace = place;
lastSize = a.size;
++place;

.replace("{{NAME}}", a.user)
.replace("{{LANGUAGE}}", a.language)
.replace("{{SIZE}}", a.size)

var lang = a.language;
lang = jQuery('<a>'+lang+'</a>').text();

languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang, user: a.user, size: a.size, link: a.link};
});

var langs = [];
for (var lang in languages)
if (languages.hasOwnProperty(lang))
langs.push(languages[lang]);

langs.sort(function (a, b) {
if (a.lang_raw.toLowerCase() > b.lang_raw.toLowerCase()) return 1;
if (a.lang_raw.toLowerCase() < b.lang_raw.toLowerCase()) return -1;
return 0;
});

for (var i = 0; i < langs.length; ++i)
{
var language = jQuery("#language-template").html();
var lang = langs[i];
language = language.replace("{{LANGUAGE}}", lang.lang)
.replace("{{NAME}}", lang.user)
.replace("{{SIZE}}", lang.size)
language = jQuery(language);
jQuery("#languages").append(language);
}

}
body {
text-align: left !important;
display: block !important;
}

width: 290px;
float: left;
}

#language-list {
width: 290px;
float: left;
}

font-weight: bold;
}

table td {
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div id="language-list">
<h2>Shortest Solution by Language</h2>
<table class="language-list">
<tr><td>Language</td><td>User</td><td>Score</td></tr>
<tbody id="languages">

</tbody>
</table>
</div>
<tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>

</tbody>
</table>
</div>
<table style="display: none">
</tbody>
</table>
<table style="display: none">
<tbody id="language-template">
</tbody>
</table>

# Ruby

## Ungolfed, 60 bytes

def fib(prev,nxt)
x = prev + nxt
puts x
fib(nxt,x)
end


## Golfed, 33 bytes

def f(a,b)x=a+b;puts x;f(b,x)end


Pretty simple to call, use f(first, next).

• You can still golf it further. Try taking out the unnecessary whitespace. Also, there are some good tips here – DJMcMayhem Sep 12 '16 at 5:14
• x=a+b;puts x can become puts x=a+b – Cyoce Dec 11 '16 at 3:26

# Java 8 29 bytes

Using Java 8 lambdas. This is a valid statement if there exists a function interface with a method that returns an int and takes an int as a parameter. Also the variable that stores the lambda must be declared as a member (static or non static) of the class it is in so that it can be used recursively.

f=n->n<2?0:f.f(n-1)+f.f(n-2);


## Ungolfed:

@FunctionalInterface interface F
{
int f(int n);
}

public class Main
{
static F f;

public static void main(String[] args)
{
f=n->n<2?0:f.f(n-1)+f.f(n-2);
}
}


# Prismatic, 113 bytes (can be smaller)

right wideness wideness left forward up vertex longness backward right vertex tallness forward down vertex vertex


Inspired by Brainfuck, Cubix and Hexagony.

# Forth, 27 bytes

Prints them forever (until it exceeds the maximum integer).

: f over . 2dup + recurse ;


Try it online

Returns the nth Fibonacci number. This assumes I can leave garbage on the stack (the result is still on top), 30 bytes:

: f 1 0 rot 0 DO 2dup + LOOP ;


Try it online

## Alice, 11 bytes

This was a collaborative golfing effort with Sp3000.

1 \ O
,+{.3


Try it online!

This prints the Fibonacci sequence indefinitely, starting from 1,1, one integer on a line. Unfortunately, it's horrible in terms of memory, because it leaks one stringified copy of each number in the sequence. The things you do for bytes...

### Explanation

1   Push 1 to initialise the sequence. There's already an implicit zero underneath.
\   Reflect to NE. Switch to Ordinal.
Immediately reflect off top boundary, move SE.

The remainder of the program runs in an infinite loop. At this point of the loop
there's the current number F_n of the sequence on top of the stack, and the
previous number F_n-1 is below.

Stack:
[... F_n-1 F_n]
.   Implicitly convert F_n to a string and duplicate it.    [... F_n-1 "F_n" "F_n"]
Reflect off bottom boundary, move NE.
O   Output F_n with a trailing linefeed.                    [... F_n-1 "F_n"]
Reflect off top right corner, move back SW.
.   Make another copy of F_n. (We don't need this one.)     [... F_n-1 "F_n" "F_n"]
Reflect off bottom boundary, move NW.
\   Reflect to S. Switch to Cardinal.
{   Turn 90 degrees left, i.e. east.
.   Implicitly convert F_n to an integer and duplicate it.  [... F_n-1 "F_n" F_n F_n]
3   Push 3.                                                 [... F_n-1 "F_n" F_n F_n 3]
,   Pull up the third stack element, which is F_n-1.        [... "F_n" F_n F_n F_n-1]
+   Add F_n and F_n-1.                                      [... "F_n" F_n F_n+1]
{   Turn 90 degrees left, i.e. north.
\   Reflect to SE. Switch to Ordinal.

After this point, the loop repeats.


# Braingolf, 23 bytes

1!_# @.!_[# @!+!_<1+>];


Try it online!

• 17 bytes – Skidsdev Jun 16 '17 at 9:20
• 14 bytes – Skidsdev Jun 16 '17 at 9:23
• 8 bytes for output the nth number – Skidsdev Jun 16 '17 at 9:35

# Joy, 45 bytes

DEFINE f ==[2<][][[1 - f][2 - f]cleave+]ifte.


Try it online! Zero-indexed. Example usage: 6 f yields 8.

[2<]                         ifte . if the top stack element is less than two
[]                            . then do nothing
[              cleave ]     . else duplicate the element and apply two functions
+      . and sum the results
[1 - f][2 - f]             . where the functions compute the two previous Fibonacci numbers


Alternative (same byte count):

DEFINE f ==[2<][][dup 1 - f swap 2 - f+]ifte.


# cQuents, 6 bytes

=1:z+y


Try it online!

This works both with and without input - it prints the sequence without input, and the nth item (1-indexed) with input n.

For 0, 1, 1, ... version, 8 bytes:

=0,1:z+y


Try it online!

# Explanation

=1      Set first item in sequence to 1
:     Mode: Sequence 1 (prints sequence with no input, or nth item with input n
z+y  Each term equals the previous two terms added together (defaults to 0)


I really, really like the way this language is going :)

• Note current version uses Z and Y instead of z and y – Stephen Feb 1 at 4:54

# ReRegex, 50 bytes.

(0+),(0+):0/$1,$2,$1$2:/.*?(0+),0+:$/$1/0,0:#input


0 indexed. Takes input and gives output via Unary.

Try it online!

ReRegex was designed to be much like an advanced version of ///. It offers the same very basic concept of repeatedly doing string match and replace operations. However, that's where the similarities end. ReRegex instead uses a list of match and replace operations, separated by /s, to perform in a loop, and the original string to effect. The Regexes will continue being performed on the original string until a constant state is achieved, at which point the program will dump the string to STDOUT.

This program in particular is just 2 regular expressions and then the input with some default values.

(0+),(0+):0  -> $1,$2,$1$2:
.*?(0+),0+:$->$1


And the input is formatted with;

0,0:#input


ReRegex defaultly replaces #input with whatever is passed to the program on STDIN.

For an example, let's say 00000 is passed to STDIN. First, the "Memory" looks like this:

0,0:00000


In the first loop, the regex (0+),(0+):0 is matched, the replace then creates the next itteration of the fibonnachi sequence.

0,0,00:0000


And in doing so, it also pops one of the 0's off, which is why :0 is at the tail end of the match, but not the replace. This then happens 4 more times in a row.

0,0,00,000,00000,00000000,0000000000000:


Now that first regex doesn't match, as there's no more :0 at the end, so we're almost at a stable end point. Now that there's nothing after :, .*?(0+),0+:$ matches, and all it does is clear all data but the second last group of 0s. 00000000  Now, nothing else matches, so it's outputted. # Joy, 28 bytes [2<][][1 - dup 1 -][+]binrec  Try it online! # Husk, 7 2 bytes (non-competing) İf  Try it online! # Forth, 39 36 bytes 0 1 : f BEGIN 2DUP + ROT . AGAIN ; f  ### Explanation First 0 and 1 are pushed to the stack. Then starts an endless loop where 2DUP duplicates the top two stack items which are then summed with +. At this point stack is 0 1 1. Then the bottom item of the stack is moved on top with ROT. . prints and removes the item on the top of the stack. Creates an endless sequence of Fibonacci numbers. Had to check out what's Forth about. And is there a better way to learn than trying to golf Fibonacci series. I see that there's already an answer with Forth but desided to post anyway. At least this is a different approach. # Proton, 24 bytes f=a=>a<2?1:f(a-1)+f(a-2)  Try it online! (Not working on TIO yet; waiting for pull) The @ is not necessary but it enables caching for the lambda which makes it considerably faster (as in, it actually finishes in a reasonable amount of time). That being said, when I tried computing it up to 10000 (which I needed to increase sys.setrecursionlimit to do), it gave me a Segmentation Fault because the program ran out of memory (Proton is very inefficient) :P • Polyglot with ES6. – Zacharý Aug 12 '17 at 21:54 • @Zacharý Huh that's cool. This is weird; Proton is often a polyglot with Python too :P – HyperNeutrino Aug 13 '17 at 0:51 # PHP, 39 bytes <?php for($b=1;;)echo$a=-$a+$b+=$a,' ';


Try it online!

Explanation

<?php


An infinite loop is started. The zero-th term in the series, initially $a, is 0, so needn't be assigned. $b is initially the second term and so is set to 1.

for ($b = 1;;)  The part which does all the work is echo$a = -$a +$b += $a, ' ';. Here it is expanded. {  Calculate the new value for $b: the next term is the sum of the previous two.

    $b =$b + $a;  $a needs to be moved on one term as well. It is calculated by subtracting itself from the new value of $b. $a = $b -$a;


For byte-saving convenience, it is $a that is echoed each time—followed by a space!  echo$a, ' ';
}


# C, 224229227 chars

## Golfed up:

#import <Foundation/Foundation.h>
typedef unsigned long long f;f main(int c,char*v[]){f n=strtoull(v[1],(char**)v[2],10)-1;f x=(c>2&&++n==0)?0:1;f y=0;while(n--!=0&&x+y>=x&&x>0){f z=x;c>2?x+=y=z:(x+=y,y=z);}printf("%llu\n",x);}


#import <Foundation/Foundation.h>
typedef unsigned long long f;
f main(int c,char*v[]){
f n=strtoull(v[1],(char**)v[2],10)-1;
f x=(c>2&&++n==0)?0:1;
f y=0;
while(n--!=0&&x+y>=x&&x>0){
f z=x;
c>2?x+=y=z:(x+=y,y=z);
}
printf("%llu\n",x);
}


If the number exceeds the length of an unsigned long long it will print the highest it can get. Return type is f (unsigned long long) for short code, it does generate 2 compiler warnings and a note but it still compiles!

It also has the option to calculate 2^n because it initially printed that.

Usage:

• ./fibbin 42 - prints 42'th fibonacci number (267914296)
• ./fibbin 42 anyInputHere - prints 2^n (4398046511104).

Don't enter values of 0, higher than 93 (fibonacci) or higher than 63 (2^n).

Examples:

• ./fibbin 1 = 1
• ./fibbin 2 = 1
• ./fibbin 3 = 2
• ./fibbin 4 = 3
• ./fibbin 42 = 267914296
• ./fibbin 92 = 7540113804746346429
• ./fibbin 93 = 12200160415121876738 - this is the highest i can go
• ./fibbin 94 = should be 19740274219868223167, but it doesn't fit into an unsigned long long so i will print #93

• ./fibbin 1 bin - 2

• ./fibbin 2 bin - 4
• ./fibbin 3 bin - 8
• ./fibbin 4 bin - 16
• ./fibbin 42 bin - 4398046511104
• ./fibbin 62 bin - 4611686018427387904
• ./fibbin 63 bin - 9223372036854775808 - this is the highest i can go
• ./fibbin 64 bin - should be 18446744073709551616, but it doesn't fit into an unsigned long long so i will print 0

These tests match the output of wolfram-alpha, due to the heavy calculations wolfram may time out but it generally doesn't.

• I'm no C expert but I think n--!=0&&... can be replaced with n--&&... – Cyoce May 2 '16 at 15:17

# Element, 12 (option two) or 11 (option one)

I've decided to go back in time and answer some classic golfing questions with Element to give it some more street cred.

The following code prints out the Fibonacci sequence continuously (it overflows rather quickly). Each number is printed separately, although there is no whitespace separation.

1!{4:~2@+}
1            push 1 onto the stack
!           flip the empty control stack to 1 to enable looping
{       }  infinite while loop
{4:     }  have 4 copies (3 additional) of the newest number on the stack
{      }  output one copy
{   ~   }  A fancy way to get zero from a copyusing the variable retrieval function
{    2~ }  Move one copy from position 0 to position 2 (behind the old number)
{      +}  add the number to the old number


The following code inputs a number and outputs the Nth number in the sequence (0-indexed).

1_'[3:~2@+]
1             push a 1
_'           take input then move it to the control stack
[      ]   FOR loop
[3:    ]   make two additional copies of the top number (3 is the total count)
[  ~   ]   turn one copy into a zero
[   2@ ]   move from position 0 to position 2, behind the old number
output the result


For completion's sake, here is a link to the interpreter.

# Recursiva, 16 bytes

<a3:1!+#~a$#~~a$


Try it online!

# Explanation:

<a3:1!+#~a$#~~a$
<a3:1            - If a<3 then 1
!           - Else
+          - Sum
#~a$- Call Self but with parameter a-1, will be replaced by result #~~a$ - Call self but with parameter a-2, will be replaced by result


# Chip-8, 36 bytes

6301 'LD v3,1
6D05 'LD vD,5
6E0A 'LD vE,A
A200 'LD I,200
F333 'LDD [I],v3
8343 'XOR v3,v4
8433 'XOR v4,v3
8343 'XOR v3,v4
F265 'LD v2,[I]
F029 'LDF I,v0
00E0 'CLS
DFF5 'DRW vF,vF,5
F129 'LDF I,v1
DDF5 'DRW vD,vF,5
F229 'LDF I,v2
DEF5 'DRW vE,vF,5
1206 'JMP 206


Displays Fibonacci numbers (up to 233) in decimal. (It might be shorter to use hexadecimal, but I think that's cheating)

This one writes the numbers into memory:

6001
A300
8014
F055
8013
8103
8013
1204


... but it's actually longer than valid numbers it writes:

01 01
02 03
05 08
0D 15
22 37
59 90
E9 79 (overflow)


# Cy, 11 + 1 (-p flag) = 12 bytes (non-competing)

This is going for the infinite stream

0 1 $&+ &do  (the -p flag implicitly prints every non-block value pushed to the stack) Literally, • push 0 • print it • push 1 • print it • forever • push the sum of the last two items • print it Without the -p flag semi-cheat: # Cy, 24 bytes 0 &:< 1 &:< {&+ &:<} &do  # J-uby, 8 6 bytes :++2.*  In J-uby, + on a proc (or a symbol in this case, as symbols can be used as procs in J-uby), defines a recurrence relation. It takes a starter array, and then produces a function that takes n, and then applies itself to the starter array n times, pushing the result to the end and removing the first element. Naturally :+ + [0,1] is a recurrence relation that starts with elements 0, 1 and adds them together n times. 2.* is shorthand for [0,1] # VBA, 28 Bytes Anonymous VBE immediate window function that takes no input and infinitely outputs the n-th term of the Fibonacci Sequence while iterating n i=1:Do:k=i+j:i=j:j=k:?j:Loop  # Brain-Flak, 36 bytes ([{}]((())<>)){({}()<(({})<>{})>)}<>  Outputs the nth number of the zero indexed Fibonacci sequence (F(0) = 1, F(1) = 1, etc.) Try it online! ## Explanation coming soon... # ><>, 12 Bytes 10:r+:nao20.  Output: 1 1 2 3 5 ...  Could save 2 bytes by removing the new line, but then there would be no separation in the output at all. ## Explanation: Pretty basic. Start by pushing 1, 0 to the stack. Duplicate the top item, reverse the stack, and sum the top two items. If we had f_n, f_n-1 on the stack before, we now have f_n+1, f_n. Duplicate the top item, and print it. 'ao' prints a new line. '20.' moves the pointer to (2,0) in the codebox, which is right after the '10'. Start again. # Pyt, 1 byte Get the nth Fibonacci number: Ḟ  Explanation:  Implicit input Ḟ Return (input)-th Fibonacci number  # Pyt, 7 bytes Get an infinite list of Fibonacci numbers: 0ĐḞƤ⁺ł  Explanation: 0 Push 0 [this is the counter]  ł While the counter is not zero (checked at 'ł') Đ Duplicate the counter ḞƤ Print the (counter)-th Fibonacci number ⁺ Increment the counter  Try it online! # tinylisp, 40 bytes The language is much newer than question, of course. (d f(q((x y)(i(disp x)1(f y(a x y (f 0 1  This is a full program that outputs Fibonacci numbers until you stop it. Try it online! The first line defines a function f that takes numbers x and y, outputs x, and calls f recursively on y and the addition of x and y. The main trick is the use of if to simulate a "do A, then B" structure: the disp call is used as the condition; its return is always falsey; so we put the recursion in the false branch. The second line calls f with 0 and 1. # QBasic, 32 bytes b=1 DO ?b b=b+a a=b-a SLEEP LOOP  Generates and prints Fibonacci numbers forever. SLEEP waits for a user keypress between numbers; otherwise, the output would scroll off the screen very rapidly. # FALSE, 13 bytes 1 1[1][$2ø+]#


Numbers are pushed to the stack.

# Japt, 3 bytes

Just to add to the collection.

0-indexed, using 0 as the first number in the sequence.

MgU


Try it

# ><>, 11 bytes

10r:n:@+aor


Try it online!

Prints the Fibonacci sequence forever, separated by newlines.

# Coconut, 28 bytes

def f(a=1,b=1)=[a]::f(b,a+b)


Try it online!