## Nearest Fibonacci number in dc

,I hadn’t really exercised my code golf skills in a while, but saw a fun challenge today that seemed like an easy solve, well-suited for `dc`

. The challenge was, given a positive integer, return the nearest Fibonacci number. The Fibonacci sequence is fun on its own in a stack language; in `dc`

one step can be performed with something like `dsf+lfr`

. Given that the stack is prepared with two integers, this will duplicate the top, store it in an intermediate register `f`

, add the two previous values, push `f`

back onto the stack, and then swap them such that they’re in the correct order. It doesn’t pollute the stack, either, these two values are all that remain.

For this challenge, those two values are all I ever need – my input (which I will refer to as `i`

) is always going to fall between two consecutive numbers in the Fibonacci sequence (or on one of them, in which case I would only need *that* value to test against). Keeping as much work on the stack as possible is ideal when golfing in `dc`

because the byte cost of working with registers adds up quickly. So my strategy is to seed the Fibonacci generator with two 1s, and run it until the larger of the two Fibonacci numbers is greater than `i`

. One of those two Fibonacci numbers will be the right one, and if `i`

happened to be a Fibonacci number, I’ve just generated an extra one for no reason. I convert both of the Fibonacci numbers to their respective differences from `i`

. Since I know for a fact that the top of the stack is greater than `i`

, and the second value on the stack is either less than or equal to `i`

, I don’t have to worry about `dc`

’s lack of an absolute value mechanism; I simply subtract `i`

from the big one and subtract the small one from `i`

. Since I know which difference is which, I have no need to retain the Fibonacci numbers. I simply compare the differences, and then reconstruct the Fibonacci number by adding or subtracting the difference to `i`

depending on which difference ‘won’. The code:

```
?si1d[dsf+lfrdli>F]dsFxli-rlir-sd[lild-pq]sDdld<Dli+p
```

…and the explanation:

```
?si Store user input in register i
1d Push 1 to stack, duplicate it to seed Fibonacci sequence
[dsf+lfrdli>F]dsFX Macro F: Fibonacci generator as described above, with the
addition of loading register i and continuing to run F
until the top-of-stack Fibonacci number is larger than i
li- Turn our high Fibonacci number into its difference
rlir- Swap the stack, and turn our low Fibonacci number into its
difference. The stack stays swapped, but it doesn't
matter
sd Store our low Fibonacci difference in register d
[lild-pq]sD Macro D: reconstruct the low Fibonacci number by
subtracting d (the difference) from i; print the result
and quit. Macro is stored for later use.
dld<D Duplicate the high Fibonacci difference and push the low
Fibonacci difference onto the stack. Compare them and run
D if the low difference is less than the high difference
li+p Else, add i to the high difference and print the result
```