Of course, if it were different problem, it'd require a different solution.

The only problem is if there is an odd number of repeated numbers then this won't work.

The gotcha with this is if you get a negative number.

I don't think Rust is a GC language.

Neat indeed!

Wow, that is elegant!

'alr approved some time ago'

I still don't get where the (b - 1) * fib(n + 2) = (b - 1) * fib(n) + (b - 1) * fib(n + 1) comes from and why should I add this to the original equation. Please, explain in details or give me link to a book or some article where it is well-explained.

@Technetium_Phenol Oh, C'mon :D It's 21st century, forget Fortran and come to Scala :D

The description is not correct.
they have fib(0) = 1
and there code doesn't calculate the fibonnaci series.

Here is my alternative expansion.

The function is recursively defined by:

0.    fib(0) = 0
1.    fib(1) = 1
2.    fib(2) = 1
3.    fib(n + 2) = fib(n) + fib(n + 1), if n + 2 > 1

3.    fib(n + 1) + fib(n + 2) = fib(n) + 2 * fib(n + 1)

The two sides of the equation look much more alike, but there is still an essential difference, which is the coefficient of the second term of each side. On the left side of the equation, it is 1 and, on the right, it is 2. To remedy this, we can introduce a variable b:

3.     b * fib(n + 1) + b * fib(n + 2) = b * fib(n) + (b + b) * fib(n + 1)

We then subtract both sides by b * fib(n+1)

3.     b * fib(n + 2) = b * fib(n) + (b + b)

To try and return the tail to the function we add both sides by a * fib(n+1) to each side:

3.     a * fib(n + 1) + b * fib(n + 2) = b * fib(n) + (a + b) * fib(n + 1)

Now the two sides have the same form (call it F), this function has the form:

3.     F(c, d, e) = F(a, b, n+1) = F(a, a+b, n) = c * fib(e) + d * fib(e + 1)

(Note if your confused by the above equation substitute the values into the furthest right function and you get)

3.     a * fib(n + 1) + b * fib(n + 2) = b * fib(n) + (a + b) * fib(n + 1) = c * fib(n) + d * fib(n + 1)

Which we can simplify to:

3.     F(a, b, n + 1) = F(b, a + b, n)

We also have, by definition of F and fib:

4.     F(a, b, 0) = a * fib(0) + b * fib(1) = b

(Proove this with general equation)
F(a, b, n + 1) with n = 0
c * fib(n) + d * fib(n + 1)
a * fib(0) + b * fib(0 + 1) as fib(0) = 0, fib(1) = 1
b

(Proove this with general equation)
c * fib(e) + d * fib(e + 1)
1 * fib(n) + 0 * fib(n + 1)
1 * fib(n)

(Proove this with general equation)
F(a, b, n + 1) with n = 1
c * fib(n) + d * fib(n + 1)
a * fib(1) + b * fib(1 + 1) as fib(1) = fib(2) = 1
a + b

def fib(n):
    if n == 0: return 0    # see 6. above
    def F(a, b, n):
        if n == 1: return a + b    # see 6. above
        return F(b, a + b, n - 1)  # see 3. above (F(a, b, n + 1) = F(b, a + b, n)) use n = n - 1
    return F(1, 0, n)              # see 5. above

The final step (optional for languages that support tail call optimization) is to replace the tail recursive function F with a loop:

def fib(n):
    if n == 0: return 0            # see 4. above
    a, b = 1, 0                    # see 5. above
    while n > 1:		
        a, b, n = b, a + b, n - 1  # see 3. above
    # n = 1 at this point
    return a + b<>                   # see 6. above 

(1) that each golfer plays "exactly once every day"
That means same set of players everyday.

GO Language Translation Added :D