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>

JavaScript (ES6) - 24 Characters (non-competing)

f=x=>x<3?1:f(x-1)+f(x-2)


JavaScript - 24 Characters (snippet)

for(a=b=1;--n;a=b-a)b+=a


Set a value for n and it will calculate the nth Fibonacci value.

• The JavaScript ES6 version should be non-competing as JavaScript ES6 was implemented after this challenge. – Downgoat Mar 25 '16 at 1:07
• Also, the second solution is invalid as it's a snippet and not a full program / function. – Downgoat Mar 25 '16 at 1:10

Stackish, 12 bytes (non-competing)

01d\+.qzcl2'


How it works:

0   Load 0 into stack (stack now 0).
1   Load 1 into stack (stack now 0,1).
d   Duplicate last number of stack (stack now 0,1,1).
\   Swap bottom with top (stack now 1,0,1).
+   Add last two numbers (stack now 1,1).
.   Pop to output (stack now 1).
q   Undo pop (stack now 1,1).
z   Pause.
c   Clear screen.

d   Duplicate last number of stack (stack now 1,1,1).
\   Swap bottom with top (stack now 1,1,1).
+   Add last two numbers (stack now 1,2).
.   Pop to output (stack now 1).
q   Undo pop (stack now 1,2).
z   Pause.
c   Clear screen.

...


JavaScript (ES6)

A couple of different ES6 implementations. The first two return the nth Fibonacci number and the third returns an array of the first n Fibonacci numbers. Non-competing, obviously.

30 bytes

f=

(n,x=1,y=0)=>!n?y:f(n-1,x+y,x)

console.log(f(10))

46 bytes

f=

n=>(x=1,y=0,eval("while(n--)[x,y]=[x+y,x]"),y)

console.log(f(10))

46 bytes

f=

n=>(a=[],(f=x=>a[x]=x<2?x:f(--x)+f(--x))(n),a)

console.log(f(10))

Axiom, 113 bytes

f(n:NNI):NNI==(n=0=>0;n:=n-1;x:=sqrt(5);floor(numeric(((x+1)/(2*x))*((1+x)/2)^n+((x-1)/(2*x))*((1-x)/2)^n)))::INT


code for test and results

(80) -> [f(i)  for i in 0..20]
(80)
[0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765]
Type: List NonNegativeInteger
(81) -> f 100
(81)  354224848179261915076
Type: PositiveInteger
(82) -> f 200
(82)  280571172992510140037336354957747795525632
Type: PositiveInteger
(83) -> f 400
(83)
1760236806450139664680709294813170892283658770059881093310828506440687624218_
31925760
Type: PositiveInteger
(84) -> f 800
(84)
6928308186422471713609360660466569632290421684876894264783997577258487494487_
420363654234099779749410573113727333378633545181944038619446626409501657425_
3135847342735360
Type: PositiveInteger
(85) -> f 1500
(85)
1355112566856310195162377575526951323656561770431639555079987987810736653460_
922122221302671882558120755439823360357867711740787668744312284056217232330_
713983569575833249689158528416736647370129969548463847884661978641646883591_
466734576231634867107272686298047871451723693301109753896341229444935835304_
2229054930944
Type: PositiveInteger
(86) -> f 2000
(86)
4224696333392304878698067179976673472756391964001565086095500593531167791551_
743662247281607190958887487440686606420026093467732621145548367502217030083_
858092272596709322168369132666938424515347258074945014044152199085287931830_
556530989999311940427567701708311778838430925973655760228465275886647451746_
556255968313014088560151159533857580044154666168801306507492995800168547537_
206536250047308876795741658264221262020608


Tampio, 107 bytes

uni on 1 lisättynä 1:een lisättynä yhteenlaskuun sovellettuna unen jäseniin ja unen hännän jäseniin


Explanation:

uni on 1 lisättynä 1:een lisättynä
uni =  1 :         1     :

yhteenlaskuun sovellettuna  unen jäseniin ja unen hännän jäseniin
(+)           zip        (uni           ,  tail uni            )


Pylons, 13 bytes

Takes the number of iterations as a command line argument to the interpreter.

11fA..+@{A,i}


How it works:

11  # Pushes 1, 1 to the stack.
fA#.##.#+@  # Creates a function "A" that takes the top two elements of the stack and adds them.
{A,i}  # Calls A sys.argv[1] times.


Axiom, 35 bytes

a(0)==0;a(1)==1;a(n)==a(n-1)+a(n-2)


above it is one succession defined by Recurrence... Results

(7) -> [a(i)  for i in 0..20]
(7)  [0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765]

• ricorrence Recurrence? – MD XF Sep 14 '17 at 4:20
• @MDXF thank you for the correction... Good morning – RosLuP Sep 14 '17 at 9:56

Pug, 30 bytes

Without input (infinite)

-a=b=1
while 1
=a
-b=a+(a=b)


Will produce an output:

1123581321345589144233377610...


With an output delimiter: 34 bytes

-a=b=1
while 1
=a+" "
-b=a+(a=b)


Will produce an output:

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


With HTML as an output delimiter: 31 bytes

-a=b=1
while 1
p=a
-b=a+(a=b)


Although I doubt this is compliant to the challenge's rules, this will produce:

<p>1</p>
<p>1</p>
<p>2</p>
<p>3</p>
<p>5</p>
<p>8</p>
<p>13</p>
<p>21</p>
<p>34</p>
<p>55</p>
...


With input (as a funcion; finite)

Without an output delimiter, 47 bytes

mixin f(n)
-a=b=1
while n--
=a
-b=a+(a=b)


For an input n=10, for example, it produces:

11235813213455


Just as it is with the infinite series versions:

• +4 bytes (+" ") = 51 bytes for a space delimiter
• +1 byte (p) = 48 bytes for an HTML <p> tag delimiter

Implicit, 12 11 bytes

]3.(,[+%:]ß


Try it online!

10 bytes (knock off the ß) if we don't need delimiters. It's not specified in the challenge... TIO

This is my own (rather simple) method of computing the sequence. Explanation:

#::.(,[+%:]ß
#::.            push 0, 0, 1 (push stack length, duplicate twice, increment last one)
(.......    forever (implicit ¶ at end of program)
,           swap top two stack values
[          pop stack into memory
+         add top two stack values
%        print
:       duplicate top of stack
]      push memory to stack
ß     print a space


In a normal language, say, C, it would look like this:

int x, y, z;
x = 0; y = 0; z = 1;

do {
swap(&y, &z);
x += y;
y = x;
printf("%d ",x);
} while (1);


Equivalence:

int x = 0, y = 0, z = 1;   // #::.
do {                       // (
swap(&y,&z);           // ,
// [ (z is ignored below)
x += y;                // +
y = x;                 // :
printf("%d ",x);       // %ß
// ] (z is ignored above)
} while (1);               // ¶


Here's how the stack looks after each operation that modifies it:

#  0
:  0 0
:  0 0 0
.  0 0 1

,  0 1 0
[  0 1
+  1
%  1
:  1 1
]  1 1 0

,  1 0 1
[  1 0
+  1
%  1
:  1 1
]  1 1 1

,  1 1 1
[  1 1
+  2
%  2
:  2 2
]  2 2 1

,  2 1 2
[  2 1
+  3
%  3
:  3 3
]  3 3 2

,  3 2 3
[  3 2
+  5
%  5
:  5 5
]  5 5 3

,  5 3 5
[  5 3
+  8
%  8
:  8 8
]  8 8 5

,  8 5 8
[  8 5
+  13
%  13
:  13 13
]  13 13 8

,  13 8 13
[  13 8
+  21
%  21
:  21 21
]  21 21 13

,  21 13 21
[  21 13
+  34
%  34
:  34 34
]  34 34 21


Golf notes:

• ]3. is shorter than #::. which is shorter than :0::1 which is shorter than :0:0:1.
• ß is shorter than @32.
• (... is shorter than :1(;...:1).

(ß, ¶, and implicit ¶ added during the writing of this program.)

Momema, 28 bytes

1 1z0-8*01+*1*00+*1-*0-9 9z1


Try it online! Outputs infinitely with a tab between numbers.

If no separator between numbers is required, you can save four bytes:

1 1z0-8*01+*1*00+*1-*0z1


Explanation

                                                     #  a = 0
1   1       #            [1] = 1                     #  b = 1
z   0       #  label z0: jump past label z0 (no-op)  #  while true {
-8  *0      #            output num [0]              #    print a
1   +*1*0   #            [1] = [1] + [0]             #    b = a + b
0   +*1-*0  #            [0] = [1] - [0]             #    a = b - a
-9  9       #            output chr 9                #    print '\t'
z1          #  label z1: jump past label z0          #  }


Reflections, 93 bytes

     \
/*\/#  (0:0\
* 0\_*;(0\/ :(0\
\     v/#@/_ /
\  (1/ 1)0)*
: \\/
\(1/


Test it!

Explanation:

Initialisation

Executing \*/(1\*/*\0\.

• * at (5|2) pushes 5×2=10 (\n)
• (1 moves the newline to stack 1
• * at (0|2) pushes 0×2=0 (F(-1))
• * at (1|1) pushes 1×1=1 (F(0))
• 0 moves these two values to stack 0

Loop

Executing v1):\(1/\\0)#/:(0\/_//\*@\0:(0#/\_*;(0\/.

• 1) pulls the newline from stack 1
• : duplicates it
• (1 moves the duplicate to stack 1
• 0) pulls the last result from stack 0
• # redefines (0|0)
• : duplicates the last result
• (0 moves the duplicate back to stack 0
• _ at (3|0) converts the last result to a list of digits
• * at (1|1) pushes 1×1=1
• @ prints the last result and a newline
• 0 pulls both values from stack 0
• : duplicates the top one (newer one)
• (0 pushes the duplicate back to stack 0
• # redefines (0|0)
• _ at (0|1) adds the two values together
• * at (1|1) pushes 1×1=1
• ; pops that again
• (0 pushes the new result to stack 0

Stax, 2 bytes

|5


Run and debug online!

Added for completeness. An internal that returns 0-indexed Fibonacci number.

Infinite sequence generator without using the internal:

ò¶AÄ∟


The ASCII equivalent is

01WQb+


SmileBASIC, 28 bytes

F.,1DEF F X,Y?Y
F Y,X+Y
END


Ungolfed:

F 0,1
DEF F X,Y
PRINT Y
F Y,X+Y
END


Elixir, 49 bytes

Defines a function to get the nth fibonacci number. 1-indexed (starts at 0).

Simple recursive formula. Slow.

def f(n)when n<2,do: n
def f(n),do: f(n-1)+f(n-2)


Try it online!

Elixir, 50 bytes

Returns an infinite stream of fibonacci numbers. 1-indexed (starts at 0).

Fast, carries over an accumulator with the sum of the previous two numbers.

fn->Stream.unfold{0,1},fn{a,b}->{a,{b,a+b}}end end


Try it online!

Javascript, 57 bytes

_=1;i=0;for(z=10;z--;)alert((a=>!(o=_+i)+(i=_)+!(_=o))())

Python 2, 33 31 bytes

i=j=1
while 1:print j;i,j=j+i,i


Try it online!

Uses a loop to infinitely print the sequence. Will eventually error out due to integer overflow. It has been pointed out to me that Python uses arbitrary precision integers. Learn something new every day!

• Python uses arbitrary precision integers so an integer overflow will not occur. – Jonathan Frech Aug 3 '18 at 14:48
• i,j=1,1 can be i=j=1. – Jonathan Frech Aug 3 '18 at 14:48

µ6, 16 bytes

[>#[,.[+.]][[,>[#/0[+/1]<>]]/1]]


Try it online!

Explanation

[>                               -- right element of the tuple generated by
#                              -- | primitive recursive function
-- | base case:
[,                            -- | | pair of
.                           -- | | | constant zero
[+.]                        -- | | | successor of constant zero
]                             -- | | : (0,1)
-- | recursive case:
[                             -- | | compose the two
[,                           -- | | | pair of
>                           -- | | | | the right element
[#/0[+/1]<>]                -- | | | | add left & right element
]                            -- | | | (snd, fst + snd)
/1                           -- | | | second argument (we only need the tuple)
]                             -- | : (f (n-1), f (n-2) + f (n-1))
]                                -- : f n


Julia 0.6, 19 bytes

!a=round(φ^a/√5)


Try it online!

This is 16 chars and 19 bytes, a goof way to abuse Julia beats the existing Julia answers which were 20 bytes. by 1 bytes and 3 chars

Little Man Computer, 45 bytes, 8 instructions

Note: both answers only work up to $$\ f(15) = 987 \$$, as the maximum value for an integer in LMC is $$\ 999 \$$.

The first solution generates Fibonacci numbers 'indefinitely':

LDA 7
STA 7
SUB 8
STA 8
OUT
BRA 0
DAT 1


and is assembled into RAM as

507 108 307 208 308 902 600 001


86 bytes, 14 instructions

The second solution returns the Fibonacci number at the index given (0-based indexing):

INP
STA 0
LDA 12
STA 12
SUB 14
STA 14
LDA 0
SUB 13
BRP 1
LDA 14
OUT
DAT 1
DAT 1


...which is assembled into RAM as:

901 300 512 114 312 214 314 500 213 801 514 902 001 001


You can test these on the online simulator here.

Tcl, 71 bytes (function implementation=43, Enter=1, call=27)

proc F x {expr $x>1?\[F$x-1]+\[F $x-2]:$x}
while 1 {puts [F [incr i]]}


Try it online!

Serves both purposes: Has a function F that allows calculate the x'th Fibonacci number. then it is called to show on stdout F applied to the whole range of positive integers.

• tcl,89: Different approach — iterative. demo — but it does not have a function and fails to represent the first one. – sergiol Jul 8 '17 at 22:17
• Failed outgolf; tcl,91 (function implementation=56, Enter=1, call=34): tio.run/##K0nO@f@/oCg/WaEkOcfKKjexJCOtNC/… – sergiol Nov 5 '17 at 17:08
• You can use less expr as there's a leading one, in escaping evaluation of each 1st brackets code 45B – david Dec 16 '18 at 20:00
• Thanks @david . I did not know I could do it by escaping [ with \. I bet I have some more answers I can golf them the way you described. – sergiol Dec 16 '18 at 20:52

R, 37 bytes

Prints the n'th term using the closed form.

https://en.wikipedia.org/wiki/Fibonacci_number#Closed-form_expression

function(n,s=5^.5)round((s/2+.5)^n/s)


Try it online!

C# (.NET Core), 68, 56 bytes

Lambda using decimal size for single n.

EDIT: Ty Jo King for pointing out better ways to assign the maths to the vars!

p=>{decimal a=0,b=1,j=0;for(;j++<p;b=a-b)a+=b;return a;}


Try it online!

Ouroboros, 10 bytes

Outputs an infinite Fibonacci sequence, starting at 0, separated by newlines.

.!+.@.nao+


Explanation

Each line of an Ouroboros program represents a snake eating its own tail. When execution reaches the end of the line, it loops back to the beginning. Each snake has a stack to store values.

If this is the first pass through the code, we need to initialize the stack by turning the top into a 1. (The empty stack is treated as containing infinite zeros.) .! dups and logically negates (1 if the value was 0, otherwise 0), and + adds that result to the top value. This has the effect of pushing a 1 if the stack was empty, and doing nothing if the stack contained a nonzero value.

Now, call the two numbers on the stack x and y, where x is smaller and y is on the top of the stack. .@.n copies y, rotates x to the top, and outputs a copy of it. a pushes 10 and o outputs it as a character (printing a newline). Finally, + adds x to a copy of y. The stack now contains y and x+y, and we proceed to the next iteration.

Try it out

// Define Stack class
function Stack() {
this.stack = [];
this.length = 0;
}
Stack.prototype.push = function(item) {
this.stack.push(item);
this.length++;
}
Stack.prototype.pop = function() {
var result = 0;
if (this.length > 0) {
result = this.stack.pop();
this.length--;
}
return result;
}
Stack.prototype.top = function() {
var result = 0;
if (this.length > 0) {
result = this.stack[this.length - 1];
}
return result;
}
Stack.prototype.toString = function() {
return "" + this.stack;
}

// Define Snake class
function Snake(code) {
this.code = code;
this.length = this.code.length;
this.ip = 0;
this.ownStack = new Stack();
this.currStack = this.ownStack;
this.alive = true;
this.wait = 0;
this.partialString = this.partialNumber = null;
}
Snake.prototype.step = function() {
if (!this.alive) {
return null;
}
if (this.wait > 0) {
this.wait--;
return null;
}
var instruction = this.code.charAt(this.ip);
var output = null;
console.log("Executing instruction " + instruction);
if (this.partialString !== null) {
// We're in the middle of a double-quoted string
if (instruction == '"') {
// Close the string and push its character codes in reverse order
for (var i = this.partialString.length - 1; i >= 0; i--) {
this.currStack.push(this.partialString.charCodeAt(i));
}
this.partialString = null;
} else {
this.partialString += instruction;
}
} else if (instruction == '"') {
this.partialString = "";
} else if ("0" <= instruction && instruction <= "9") {
if (this.partialNumber !== null) {
this.partialNumber = this.partialNumber + instruction;  // NB: concatenation!
} else {
this.partialNumber = instruction;
}
next = this.code.charAt((this.ip + 1) % this.length);
if (next < "0" || "9" < next) {
// Next instruction is non-numeric, so end number and push it
this.currStack.push(+this.partialNumber);
this.partialNumber = null;
}
} else if ("a" <= instruction && instruction <= "f") {
// a-f push numbers 10 through 15
var value = instruction.charCodeAt(0) - 87;
this.currStack.push(value);
} else if (instruction == "\$") {
// Toggle the current stack
if (this.currStack === this.ownStack) {
this.currStack = this.program.sharedStack;
} else {
this.currStack = this.ownStack;
}
} else if (instruction == "s") {
this.currStack = this.ownStack;
} else if (instruction == "S") {
this.currStack = this.program.sharedStack;
} else if (instruction == "l") {
this.currStack.push(this.ownStack.length);
} else if (instruction == "L") {
this.currStack.push(this.program.sharedStack.length);
} else if (instruction == ".") {
var item = this.currStack.pop();
this.currStack.push(item);
this.currStack.push(item);
} else if (instruction == "m") {
var item = this.ownStack.pop();
this.program.sharedStack.push(item);
} else if (instruction == "M") {
var item = this.program.sharedStack.pop();
this.ownStack.push(item);
} else if (instruction == "y") {
var item = this.ownStack.top();
this.program.sharedStack.push(item);
} else if (instruction == "Y") {
var item = this.program.sharedStack.top();
this.ownStack.push(item);
} else if (instruction == "\\") {
var top = this.currStack.pop();
var next = this.currStack.pop()
this.currStack.push(top);
this.currStack.push(next);
} else if (instruction == "@") {
var c = this.currStack.pop();
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(b);
this.currStack.push(c);
this.currStack.push(a);
} else if (instruction == ";") {
this.currStack.pop();
} else if (instruction == "+") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(a + b);
} else if (instruction == "-") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(a - b);
} else if (instruction == "*") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(a * b);
} else if (instruction == "/") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(a / b);
} else if (instruction == "%") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(a % b);
} else if (instruction == "_") {
this.currStack.push(-this.currStack.pop());
} else if (instruction == "I") {
var value = this.currStack.pop();
if (value < 0) {
this.currStack.push(Math.ceil(value));
} else {
this.currStack.push(Math.floor(value));
}
} else if (instruction == ">") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(+(a > b));
} else if (instruction == "<") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(+(a < b));
} else if (instruction == "=") {
var b = this.currStack.pop();
var a = this.currStack.pop();
this.currStack.push(+(a == b));
} else if (instruction == "!") {
this.currStack.push(+ !this.currStack.pop());
} else if (instruction == "?") {
this.currStack.push(Math.random());
} else if (instruction == "n") {
output = "" + this.currStack.pop();
} else if (instruction == "o") {
output = String.fromCharCode(this.currStack.pop());
} else if (instruction == "r") {
var input = this.program.io.getNumber();
this.currStack.push(input);
} else if (instruction == "i") {
var input = this.program.io.getChar();
this.currStack.push(input);
} else if (instruction == "(") {
this.length -= Math.floor(this.currStack.pop());
this.length = Math.max(this.length, 0);
} else if (instruction == ")") {
this.length += Math.floor(this.currStack.pop());
this.length = Math.min(this.length, this.code.length);
} else if (instruction == "w") {
this.wait = this.currStack.pop();
}
// Any unrecognized character is a no-op
if (this.ip >= this.length) {
// We've swallowed the IP, so this snake dies
this.alive = false;
this.program.snakesLiving--;
} else {
// Increment IP and loop if appropriate
this.ip = (this.ip + 1) % this.length;
}
return output;
}
Snake.prototype.getHighlightedCode = function() {
var result = "";
for (var i = 0; i < this.code.length; i++) {
if (i == this.length) {
result += '<span class="swallowedCode">';
}
if (i == this.ip) {
if (this.wait > 0) {
result += '<span class="nextActiveToken">';
} else {
result += '<span class="activeToken">';
}
result += escapeEntities(this.code.charAt(i)) + '</span>';
} else {
result += escapeEntities(this.code.charAt(i));
}
}
if (this.length < this.code.length) {
result += '</span>';
}
return result;
}

// Define Program class
function Program(source, speed, io) {
this.sharedStack = new Stack();
this.snakes = source.split(/\r?\n/).map(function(snakeCode) {
var snake = new Snake(snakeCode);
snake.program = this;
snake.sharedStack = this.sharedStack;
return snake;
}.bind(this));
this.snakesLiving = this.snakes.length;
this.io = io;
this.speed = speed || 10;
this.halting = false;
}
Program.prototype.run = function() {
this.step();
if (this.snakesLiving) {
this.timeout = window.setTimeout(this.run.bind(this), 1000 / this.speed);
}
}
Program.prototype.step = function() {
for (var s = 0; s < this.snakes.length; s++) {
var output = this.snakes[s].step();
if (output) {
this.io.print(output);
}
}
this.io.displaySource(this.snakes.map(function (snake) {
return snake.getHighlightedCode();
}).join("<br>"));
}
Program.prototype.halt = function() {
window.clearTimeout(this.timeout);
}

var ioFunctions = {
print: function (item) {
var stdout = document.getElementById('stdout');
stdout.value += "" + item;
},
getChar: function () {
if (inputData) {
var inputChar = inputData[0];
inputData = inputData.slice(1);
result = inputChar.charCodeAt(0);
} else {
result = -1;
}
var stdinDisplay = document.getElementById('stdin-display');
stdinDisplay.innerHTML = escapeEntities(inputData);
return result;
},
getNumber: function () {
while (inputData && (inputData[0] < "0" || "9" < inputData[0])) {
inputData = inputData.slice(1);
}
if (inputData) {
var inputNumber = inputData.match(/\d+/)[0];
inputData = inputData.slice(inputNumber.length);
result = +inputNumber;
} else {
result = -1;
}
var stdinDisplay = document.getElementById('stdin-display');
stdinDisplay.innerHTML = escapeEntities(inputData);
return result;
},
displaySource: function (formattedCode) {
var sourceDisplay = document.getElementById('source-display');
sourceDisplay.innerHTML = formattedCode;
}
};
var program = null;
var inputData = null;
function showEditor() {
var source = document.getElementById('source'),
sourceDisplayWrapper = document.getElementById('source-display-wrapper'),
stdin = document.getElementById('stdin'),
stdinDisplayWrapper = document.getElementById('stdin-display-wrapper');

source.style.display = "block";
stdin.style.display = "block";
sourceDisplayWrapper.style.display = "none";
stdinDisplayWrapper.style.display = "none";

source.focus();
}
function hideEditor() {
var source = document.getElementById('source'),
sourceDisplay = document.getElementById('source-display'),
sourceDisplayWrapper = document.getElementById('source-display-wrapper'),
stdin = document.getElementById('stdin'),
stdinDisplay = document.getElementById('stdin-display'),
stdinDisplayWrapper = document.getElementById('stdin-display-wrapper');

source.style.display = "none";
stdin.style.display = "none";
sourceDisplayWrapper.style.display = "block";
stdinDisplayWrapper.style.display = "block";

var sourceHeight = getComputedStyle(source).height,
stdinHeight = getComputedStyle(stdin).height;
sourceDisplayWrapper.style.minHeight = sourceHeight;
sourceDisplayWrapper.style.maxHeight = sourceHeight;
stdinDisplayWrapper.style.minHeight = stdinHeight;
stdinDisplayWrapper.style.maxHeight = stdinHeight;
sourceDisplay.textContent = source.value;
stdinDisplay.textContent = stdin.value;
}
function escapeEntities(input) {
return input.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}
function resetProgram() {
var stdout = document.getElementById('stdout');
stdout.value = null;
if (program !== null) {
program.halt();
}
program = null;
inputData = null;
showEditor();
}
function initProgram() {
var source = document.getElementById('source'),
stepsPerSecond = document.getElementById('steps-per-second'),
stdin = document.getElementById('stdin');
program = new Program(source.value, +stepsPerSecond.innerHTML, ioFunctions);
hideEditor();
inputData = stdin.value;
}
function runBtnClick() {
if (program === null || program.snakesLiving == 0) {
resetProgram();
initProgram();
} else {
program.halt();
var stepsPerSecond = document.getElementById('steps-per-second');
program.speed = +stepsPerSecond.innerHTML;
}
program.run();
}
function stepBtnClick() {
if (program === null) {
initProgram();
} else {
program.halt();
}
program.step();
}
function sourceDisplayClick() {
resetProgram();
}
.container {
width: 100%;
}
.so-box {
font-family:'Helvetica Neue', Arial, sans-serif;
font-weight: bold;
color: #fff;
text-align: center;
font-size: 1em;
line-height: 1.1;
border: 1px solid #c47b07;
-webkit-box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
text-shadow: 0 0 2px rgba(0, 0, 0, 0.5);
background: #f88912;
box-shadow: 0 2px 2px rgba(0, 0, 0, 0.3), 0 2px 0 rgba(255, 255, 255, 0.15) inset;
}
.control {
display: inline-block;
float: left;
margin-right: 25px;
cursor: pointer;
}
.option {
margin-right: 25px;
float: left;
}
h1 {
text-align: center;
font-family: Georgia, 'Times New Roman', serif;
}
a {
text-decoration: none;
}
input, textarea {
box-sizing: border-box;
}
textarea {
display: block;
white-space: pre;
overflow: auto;
height: 100px;
width: 100%;
max-width: 100%;
min-height: 25px;
}
span[contenteditable] {
background: #cc7801;
color: #fff;
}
#stdout-container, #stdin-container {
height: auto;
}
#reset {
float: right;
}
#source-display-wrapper , #stdin-display-wrapper{
display: none;
width: 100%;
height: 100%;
overflow: auto;
border: 1px solid black;
box-sizing: border-box;
}
#source-display , #stdin-display{
font-family: monospace;
white-space: pre;
}
.activeToken {
background: #f93;
}
.nextActiveToken {
background: #bbb;
}
.swallowedCode{
color: #999;
}
.clearfix:after {
content:".";
display: block;
height: 0;
clear: both;
visibility: hidden;
}
.clearfix {
display: inline-block;
}
* html .clearfix {
height: 1%;
}
.clearfix {
display: block;
}
<!--
Designed and written 2015 by D. Loscutoff
Much of the HTML and CSS was taken from this Befunge interpreter by Ingo Bürk: http://codegolf.stackexchange.com/a/40331/16766
-->
<div class="container">
<textarea id="source" placeholder="Enter your program here" wrap="off">.!+.@.nao+</textarea>
<div id="source-display-wrapper" onclick="sourceDisplayClick()"><div id="source-display"></div></div></div><div id="stdin-container" class="container">
<textarea id="stdin" placeholder="Input" wrap="off"></textarea>
<div id="stdin-display-wrapper" onclick="stdinDisplayClick()"><div id="stdin-display"></div></div></div><div id="controls-container" class="container clearfix"><input type="button" id="run" class="control so-box" value="Run" onclick="runBtnClick()" /><input type="button" id="pause" class="control so-box" value="Pause" onclick="program.halt()" /><input type="button" id="step" class="control so-box" value="Step" onclick="stepBtnClick()" /><input type="button" id="reset" class="control so-box" value="Reset" onclick="resetProgram()" /></div><div id="stdout-container" class="container"><textarea id="stdout" placeholder="Output" wrap="off" readonly></textarea></div><div id="options-container" class="container"><div class="option so-box">Steps per Second:
<span id="steps-per-second" contenteditable>20</span></div></div>

\/\/>, 9 bytes

:@+1}:nau


Outputs infinitely starting from 0, with each number on a new line.

Explanation:

:           Dupe top of stack
@          Rotate the top three elements
+         Add the top two elements
1}       Push a 1 to the bottom of the stack
:nau   Print the top number with a trailing newline


33, 7 bytes

1c[oca]


Not a Fibonacci number, I'm afraid.

Golfscript 42 bytes

~:n;2 -1?:h;5h?:f;1f+2/:p;p n?-1p*n~)?-f/


I origionally solved this in python with 64chars because i didn't think golfscript supported floats. I did some more digging and it actually does if you raise a number to -1.

Back in my graph theory/combinitorics class we went over creating an O(1) form of recurance eqautions, the fibonacci sequence is one example we used. I don't remeber the method for converting a recurance equation to constant time because the class was a few years ago, but I found the solution for the fibonacci equation online

This allows you to compute the nth fibbonacci number without computing the previous terms

• You're correct, hardcoing phi is a bit messy, see my updated answer using golfscript and not hardcoding any values – wade king Aug 28 at 23:53

8086/8088 machine code, 8 bytes

The machine code is on the left; the middle column is disassembly and the rightmost column is an explanation.

40      ; inc ax          set ax to 1
41      ; inc cx          set cx to 1
ef      ; out [dx], ax    output ax to port [dx] (that is, port 0)
03 c1   ; add ax, cx      set ax to ax + cx
91      ; xchg ax, cx     exchange ax with cx


Assumptions:

• The registers AX, CX and DX are initially 0.
• A number may be output by writing it as a word to port 0.

This runs forever, outputting the Fibonacci numbers modulo $$\2^{16}\$$ = 65,536, starting with 1, 1.

Oasis, 2 bytes

Answer to the open exercise on the Oasis repo.

+T


Explanation

Expanded program:

bc+10


When + requires 1 parameter, it tries to calculate a(n-1). For the other parameter, it tries to calculate a(n-2). (Hence the expansion.)

In addition, the T instruction expands to 10 in the program, which are the base test cases (a(0) is 0. a(1) is 1. Since base test cases are popped from the end before the Oasis program is executed in reverse.)

TIO

C (gcc), 57 bytes

x=0,y=1,s;main(){for(;;){s=x+y;printf("%d,",s);x=y;y=s;}}


Try it online!

• Shouldn't you be starting at 1,1,2,3...? Also, you can omit the =0, and instead of for(;;), you can call main() again. Try it online! – Jo King Oct 21 at 4:41
• @ceilingcat And even further (assuming no arguments) 45 bytes – Jo King Oct 21 at 20:31
• or 41 bytes with a different interpreter – Jo King Oct 21 at 21:31