16
\$\begingroup\$

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
\$\endgroup\$
2
  • 6
    \$\begingroup\$ This question will need a scoring criteria, input/output specification, etc. Please read the FAQ - codegolf.stackexchange.com/faq \$\endgroup\$
    – ardnew
    Jul 26 '12 at 20:27
  • \$\begingroup\$ @ardnew: I'll try to at least nail down an input (namely none) and winning criterion (shortest code). The expected output is, well...most languages support double-precision, so let's do that and call it good. :-) \$\endgroup\$ Jul 30 '12 at 17:22

32 Answers 32

19
\$\begingroup\$

Perl, Python - 10 chars

probably other languages too

.5+5**.5/2
\$\endgroup\$
2
9
\$\begingroup\$

Julia 0.7, 2 bytes

φ

Try it online!

I'm surprised nobody has posted this yet...

\$\endgroup\$
4
  • \$\begingroup\$ That’s an old version of Julia! Does it not work in 1.5? \$\endgroup\$
    – user9207
    Aug 27 '20 at 6:21
  • 2
    \$\begingroup\$ Julia 1.0+ moved a lot of stuff out of Base, often making the code much more verbose... \$\endgroup\$
    – Kirill L.
    Aug 27 '20 at 8:58
  • \$\begingroup\$ Why it's 2 bytes? I just see one character, does the tab include in length of program? \$\endgroup\$ Nov 19 '20 at 9:22
  • 2
    \$\begingroup\$ @AmirrezaRiahi Unlike golfing languages, Julia doesn't use a custom codepage, so this is scored in UTF-8, where greek letters use 2 bytes. \$\endgroup\$
    – Kirill L.
    Nov 19 '20 at 17:17
7
\$\begingroup\$

Mathematica 11

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

\$\endgroup\$
6
\$\begingroup\$

k (10 chars)

As continued fraction:

{%x%x+1}/1

Or in closed form for 11:

%2%1+sqrt 5
\$\endgroup\$
6
\$\begingroup\$

J, 7 chars

-:1+%:5

some more text for the filter (my first J solution, heh)

\$\endgroup\$
2
  • \$\begingroup\$ When I run -: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\$
    – r.e.s.
    Jul 31 '12 at 2:23
  • \$\begingroup\$ @r.e.s the question asks " to display, return, or evaluate". It is evaluated to the correct precision, just not displayed. It's a compliant answer. \$\endgroup\$
    – Griffin
    Jul 31 '12 at 10:10
6
\$\begingroup\$

PHP 17 chars

This one is just trolling, but hey.

1.618033988749895
\$\endgroup\$
0
6
\$\begingroup\$

APL, 7

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.

\$\endgroup\$
1
  • 3
    \$\begingroup\$ Dyalog APL: 1+∘÷⍣=1 \$\endgroup\$ Jul 4 '20 at 18:20
4
\$\begingroup\$

JavaScript (ECMAScript), 10 chars

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
\$\endgroup\$
1
  • 1
    \$\begingroup\$ There's now a ** operator, so 5**.5/2+.5 would work too. Note that this is the same as the python submission. \$\endgroup\$ Jul 3 '20 at 19:33
3
\$\begingroup\$

Language Agnostic, 15 chars

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.

\$\endgroup\$
2
  • \$\begingroup\$ 9227465/5702887 produces only 13 correct digits - it differs on 14. digit. \$\endgroup\$
    – Tomas
    Feb 2 '14 at 3:24
  • 1
    \$\begingroup\$ 14930352/9227465 is probably the shortest, you can find it using optimal algorithm as advised on math.SE \$\endgroup\$
    – Tomas
    Feb 2 '14 at 3:37
3
\$\begingroup\$

dc, 8 chars

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.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ It can be argued that the p is not needed, because the requirement is to evaluate (not necessarily display) to 15 places. \$\endgroup\$
    – r.e.s.
    Feb 2 '14 at 2:02
  • \$\begingroup\$ @r.e.s. interesting bending of rules :) thanks, updated :) \$\endgroup\$
    – Tomas
    Feb 2 '14 at 2:53
3
\$\begingroup\$

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

\$\endgroup\$
3
\$\begingroup\$

Arn, 3 bytes

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.

6 bytes

l[├Qn0

Try it!

Explanation

Unpacked: :-1+:/5

:-       Halve
    1    Literal one
  +      Plus
    :/   Square root of
      5  Literal five
\$\endgroup\$
2
  • \$\begingroup\$ arn has no increment command? \$\endgroup\$
    – Razetime
    Nov 19 '20 at 9:19
  • 1
    \$\begingroup\$ The increment command is two bytes, ++. This increments variables too, which gives it a unique purpose. \$\endgroup\$ Nov 19 '20 at 16:55
3
\$\begingroup\$

Husk, 4 bytes

(floating-point; accurate to 15 significant figures)

½→√5

Try it online!

This seems (to me) to be surprisingly readable for a golfing language...

  √5    # square root of 5
 →      # increment 
½       # halve

Husk, 9 bytes

(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)
\$\endgroup\$
2
\$\begingroup\$

Ruby - 14 chars

(­5**0.5)/2+0.5

Based on the Javascript Perl answer above.

\$\endgroup\$
3
  • \$\begingroup\$ Better base it on the Perl answer instead, 5**0.5 is shorter than Math.sqrt(­5). \$\endgroup\$ Sep 27 '12 at 14:14
  • \$\begingroup\$ My mind was skipping on me, as I could not recall what the exponential equivalent to sqrt was.... \$\endgroup\$ Sep 27 '12 at 14:21
  • 2
    \$\begingroup\$ 8 years late... the parentheses are not needed. \$\endgroup\$
    – Dingus
    Apr 23 '20 at 0:30
2
\$\begingroup\$

Almost language agnostic, 9 chars

(tested in R):

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

\$\endgroup\$
2
\$\begingroup\$

05AB1E, 6 bytes

5X‚t;O

Try it online!

Explanation

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
\$\endgroup\$
2
\$\begingroup\$

x86 machine code, 13 bytes

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

\$\endgroup\$
2
\$\begingroup\$

Python 3, 11 bytes

(1+5**.5)/2

= 1.618033988749895

\$\endgroup\$
1
  • \$\begingroup\$ Welcome to the site! \$\endgroup\$ Nov 19 '20 at 12:32
2
+50
\$\begingroup\$

Whispers v3, 16 bytes

> φ
>> Output 1

Try it online!

\$\endgroup\$
1
\$\begingroup\$

dc - 11 chars

15k5v2/.5+p

The most character-consuming task is setting the decimal precision..

\$\endgroup\$
0
1
\$\begingroup\$

Mathematica - 31

N[x/.Solve[x^2-x-1==0][[2]],16]

1.618033988749895

(It's going to be the longest code, I expect...:)

\$\endgroup\$
1
\$\begingroup\$

Japt, 2 bytes

MQ

Test it

Or 6 bytes without the built-in:

½+5¬/2

Test it

\$\endgroup\$
1
1
\$\begingroup\$

MathGolf, 1 byte

φ

Builtins ftw ¯\_(ツ)_/¯

Try it online.

Without builtins it's 6 bytes:

51α√½Σ

Try it online.

Explanation:

φ       # Push golden ratio builtin 1.618033988749895
        # (output the entire stack joined together implicitly as result)

5       # Push 5
 1      # Push 1
  α     # Wrap the last two values into a list: [5,1]
   √    # Take the square-root of each value: [2.23606797749979,1.0]
    ½   # Halve each: [1.118033988749895,0.5]
     Σ  # And sum this list: 1.618033988749895
        # (after which the entire stack joined together is output implicitly as result)
\$\endgroup\$
1
\$\begingroup\$

CJam, 7 bytes

X5mq+2/

Try it online

Just one more byte than 05AB1E! Pretty simple stack-based translation of the equation on the Wikipedia page:

X5         Push 1 and 5 on to the stack
  mq       Square root the top number
    +      Add the top two numbers on the stack
     2/    Divide by two
           (implicit) output the stack
\$\endgroup\$
2
  • 2
    \$\begingroup\$ I've removed the non-competing tag as that no longer exists, but otherwise, nice first answer! Be sure to check out our tips for golfing in CJam as well, and hope you enjoy it here! \$\endgroup\$ Jul 11 '20 at 21:34
  • \$\begingroup\$ @caird Thanks! I've read old Code Golf threads for a while and I've seen that a few times, so I figured it was required. Thanks for the tips, I'm glad to finally try participating! \$\endgroup\$ Jul 11 '20 at 21:37
1
\$\begingroup\$

MUMPS, 11 bytes

w 5**.5+1/2

Output: 1.618033988749894849

This highlights a quick about MUMPS: order of operations is evaluated left to right. Something like .5+5**.5/2 would give us (5.5**.5)/2 (1.172603939955857389).

\$\endgroup\$
1
\$\begingroup\$

05AB1E, 4 bytes

5t>;

Try it online!

5t>;  # full program
   ;  # divide...
 t    # square root of...
5     # literal...
  >   # plus 1...
   ;  # by 2
      # implicit output
\$\endgroup\$
1
\$\begingroup\$

Pyth, 3 bytes

.n3

Try it online!

11 bytes without builtin:

+c@5 2 2 .5

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Python, 33 bytes

ratio=(1+5**(1/2))/2
print(ratio)

Output:

1.618033988749895
\$\endgroup\$
4
  • 1
    \$\begingroup\$ Welcome to the site! You should indicate in your answer which language this is, as well as the byte count. Furthermore, I've edited your answer slightly to improve the formatting. Could you also edit in a link to a site where users can test your code, such as Try It Online!? Hope you enjoy it here at CGCC! \$\endgroup\$ Aug 26 '20 at 21:22
  • 1
    \$\begingroup\$ (1+5**(1/2))/2 is by itself is a snippet so wouldn't be a valid answer, and ratio=(1+5**(1/2))/2<newline>print(ratio) is sufficiently long it may not be a serious contender for the winning criteria of the challenge. \$\endgroup\$ Dec 6 '20 at 22:46
  • \$\begingroup\$ 22 bytes, making it a serious submission \$\endgroup\$
    – lyxal
    Dec 7 '20 at 0:05
  • 1
    \$\begingroup\$ @Lyxal 19 bytes \$\endgroup\$ Dec 7 '20 at 0:12
0
\$\begingroup\$

C (gcc), 37 bytes

Very basic solution, calculates exact value & prints.

main(){printf("%.15f",.5+sqrt(5)/2);}

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Jelly, 2 bytes

Øp

Try it online!

\$\endgroup\$

Your Answer

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