Write the shortest code, in number of bytes, to display, return, or evaluate to the golden ratio (that is, the positive root of the quadratic equation: \$x^2-x-1=0\$, approximately 1.618033988749895), to at least 15 significant figures. No input will be given to your program.
Sample in Stutsk programming language:
1 100 { 1 + 1 swp / } repeat print probably other languages too
.5+5**.5/2 
.5+5^.5/2 will work in Octave/MATLAB, probably some others too \$\endgroup\$ 
tab include in length of program? \$\endgroup\$ 
GoldenRatio This is the irrational number itself, not an approximation of it.
Examples (first 2 examples from Mathematica documentation)
FullSimplify[GoldenRatio^4 - GoldenRatio] FullSimplify[GoldenRatio^20 + 1/GoldenRatio^20] FullSimplify[GoldenRatio^2 - GoldenRatio - 1] 3 + Sqrt[5]
15127
0
PHP 17 chars
This one is just trolling, but hey.
1.618033988749895 
2÷⍨1+√5 ÷2÷1+√5 .5×1+√5 .5+√5÷4 Curses! I can't find a way to do it in less than 7 characters! Dialect is Nars2000.
1+∘÷⍣=1 \$\endgroup\$ As continued fraction:
{%x%x+1}/1 Or in closed form for 11:
%2%1+sqrt 5 
-:1+%:5 some more text for the filter (my first J solution, heh)
-:1+%:5, the result is 1.61803. Is something more needed in the program (or system settings) to get the required "at least 15 significant figures"? \$\endgroup\$ +++++++[>+++++++<-]>.---.++++++++.-----.+++++++.--------.+++..++++++.-..-.---.+++++.-.+.----. It works :/ Not very optimised though. I can’t think of any way to optimize this, although I’m sure a way exists.
Explanation:
+++++++ Add seven to cell at 0. [ Begin a loop. >+++++++ Add seven to cell at 1. < Go back to cell 0. - Decrement the counter there (soon it will reach 0). ] End loop when cell 0 reaches 0 after 7 repetitions. > Go to cell 1 which is now 49. . Print it (1). ---. Decrement 3 to get 46 (period) then print it. Afterwards, not much explanation is needed. Just add some or subtract some and repeat until everything is printed. ++++++++.-----.+++++++.--------.+++..++++++.-..-.---.+++++.-.+.----. 
5**.5/2+.5 This is the same as the Perl & Python submission - thanks to Redwolf Programs for telling me about this.
However, back in 2012, when this answer was originally written, the ** operator did not exist in JavaScript. While almost all browsers and do now support the exponentiation operator, according to Can I Use, as of July 2020, around 9% of users still does not support it, including the latest version of Internet Explorer. Thus, the old version of the answer:
JavaScript (backwards-compatible), 17 chars
Math.sqrt(5)/2+.5 
** operator, so 5**.5/2+.5 would work too. Note that this is the same as the python submission. \$\endgroup\$ 5X‚t;O 5 Push 5 X Push 1 ‚ Pair: [5, 1] t Square root: [2.23606797749979, 1.0] ; Halve: [1.118033988749895, 0.5] O Sum: 1.618033988749895 9227465/5702887 If all you need is enough precision for an IEEE 32 bit float, you can do it in 9 chars:
6765/4181 This will only work for languages that don't treat integer division specially.
9227465/5702887 produces only 13 correct digits - it differs on 14. digit. \$\endgroup\$ 14930352/9227465 is probably the shortest, you can find it using optimal algorithm as advised on math.SE \$\endgroup\$ Fk5v1+2/ The value is on top of the stack - can be printed by adding p to the end of the program. F pushes 15 on the stack (trick found here), k sets the precision to 15 digits. The rest is normal postfix notation :-) v is a square root. Trailing p for print was omitted.
p is not needed, because the requirement is to evaluate (not necessarily display) to 15 places. \$\endgroup\$ J, 10 9 8 chars
p.1,1,_1 (root of polynomial: -x^2+x+1)
>:@%^:_+1 (continued fraction (9 chars))
%:@>:^:_+1 (continued root: (10 chars))
phi Just a builtin, too short to be compressed. Returns 1.61803398874989484820458683436563811.
A more interesting one. If running in the downloadable version, this will print n digits, given the command:
arn run file.arn -p n or 25 digits if the -p flag is not provided.
If running in the online version, this will print the first 50 digits.
l[├Qn0 Unpacked: :-1+:/5
:- Halve 1 Literal one + Plus :/ Square root of 5 Literal five 
++. This increments variables too, which gives it a unique purpose. \$\endgroup\$ (floating-point; accurate to 15 significant figures)
½→√5 This seems (to me) to be surprisingly readable for a golfing language...
√5 # square root of 5 → # increment ½ # halve (calculation as arbitrary precision rational number)
!Ẋ/İf!5İ⁰ Try it online! (TIO header converts the rational number [expressed in Husk as a fraction] to its first 1000 decimal digits)
/ # get the ratio of Ẋ # every pair of elements of İf # the fibonacci sequence; ! # now select the ratio at position !5İ⁰ # 10^5 (change to !9İ⁰ for more accuracy with same byte-count) 
(1+1%)/1 Adapted from the built-in docs.
(...)/1 set up a converge-reduce, seeded with 1 and run until two successive iterations return the same result (1+1%) add one to the inverse of the current value, and feed that into the next iteration
(5**0.5)/2+0.5 Based on the Javascript Perl answer above.
5**0.5 is shorter than Math.sqrt(5). \$\endgroup\$ sqrt was.... \$\endgroup\$ .5+5^.5/2 In R, evaluates full double precision. More digits can be seen by setting options(digits=99). The question says "evaluate", so that goes with the rules.
= sign before this. \$\endgroup\$ Hexdump:
b1 7f d9 e8 d9 e8 de c1 d9 fa e2 f8 c3 Disassembly:
100139D0 B1 7F mov cl,7Fh 100139D2 D9 E8 fld1 again: 100139D4 D9 E8 fld1 100139D6 DE C1 faddp st(1),st 100139D8 D9 FA fsqrt 100139DA E2 F8 loop again (100139D4h) 100139DC C3 ret Uses the converging sequence an = sqrt(an-1 + 1).
The number of iterations is determined by the contents of ecx, which is mostly garbage. The minimal number of iterations is 127, which guarantees good precision (actually, 30 iterations should be enough). In the worst case, the calculation will take a few minutes (232-1 iterations), and in the best case, it's instantaneous (127 iterations).
(1+5**.5)/2 = 1.618033988749895
Saved 4 bytes!
After posting this answer I noticed the example Stutsk program and realized that I could probably save a few bytes. My new answer is based off the example given in the question. This program works because the golden ration can be expressed as a continued fraction.
golden_ratio = 1+1/(1+1/(1+1/...))
ff*101.;n~< $1$,1+$:?!^1- f201.;n,2+1~< $:5$,+2,$:?!^1- The second line approximates the sqrt of 5. After looping 15 times, this value is used to calculate the golden ratio.
=5e.5+/p =5 set top of stack to 5 e.5 square root + increment / divide by 2 p print value This first approach is pretty boring, it's just a direct calculation. Here's a slightly more exciting 13-byte method which calculates many Fibonacci numbers then finds the ratio between them:
+s[+~$]99$/~p +s increment the top of the stack (to 1) and save to memory [ ]99 loop 99 times +~ increment top of stack by the value in memory $ swap the top of the stack for the value in memory $ swap the top of the stack for the value in memory /~ divide the top of the stack by the value in memory p print value 
.5(1+√(5 pretty simple
phi is from golden mean,a number I really do see commonly having a mystical proportion for its Fibonacci sequence:important numbers Leonardo Bonacci gave Fibonacci sequence beautiful name golden X Outputs 1.618033988749894; the digits are hardcoded.
PUT XX:FOUR SEXTET PUSH I OUTPUT N OUTPUT CH PUT XXX:I BI FIFTH PUT XX:I NUMBERZERO PUT XX:FOUR BI STACKTOP POW STACKTOP PRODUCTOF PUSH I PUSH TRI STACKTOP MINUS STACKTOP POW PUT XX:I NUMBERZERO PUT XX:BI I STACKTOP POW PUSH FIFTH STACKTOP PRODUCTOF STACKTOP MINUS OUTPUT N Outputs 1.6180339887498948482045; prints the number 1, then ., then the result of \$\lfloor \sqrt{125 \times 10^{42}} \rfloor - 5 \times 10^{21}\$ (the closest integer approximation of \$(\phi - 1) \times 10^{22}\$).
15k5v2/.5+p The most character-consuming task is setting the decimal precision..
N[x/.Solve[x^2-x-1==0][[2]],16] 1.618033988749895 (It's going to be the longest code, I expect...:)
