## Interpreting 69lang (a ;# dialect) in dc

,PPCG user caird coinheringaahing came up with a language, `;#`

, and a code golf challenge to implement an interpreter thereof. The language has two commands: `;`

adds one to the accumulator, `#`

mods the accumulator 127, outputs its ASCII counterpart, and resets the accumulator. It is, quite clearly, a language that only exists for the sake of this challenge. I mostly do challenges that I can do in dc, which this challenge is not (dc simply cannot do anything with strings).

What I can do is establish a dialect of `;#`

wherein the commands are transliterated to digits^{1}. I’ve opted for 6 and 9, because I am a mature adult. So, assuming the input is a gigantic number, the challenge is fairly trivial in dc: `0sa[10~rdZ1<P]dsPx[6=Ala127%P0sa]sR[la1+saq]sA[lRxz0<M]dsMx`

`0sa`

initializes our accumulator, `a`

, to zero. Our first macro, `[10~rdZ1<P]dsPx`

breaks a (presumably very large) number into a ton of single-digit entries on the stack. `~`

yields mod and remainder, which makes the task quite simple – we keep doing `~10`

, `r`

eversing the top-of-stack, and checking the length of our number. Once it’s down to a single digit, our stack is populated with commands.

The main macro, `[lRxz0<M]dsMx`

runs macro `R`

, makes sure there are still commands left on the stack, and loops until that is no longer true. `R`

, that is, `[6=Ala127%P0sa]sR`

tests if our command is a `6`

(nee `;`

), and runs `A`

if so. `A`

has a `q`

command in it that exits a calling macro, which means everything else in `R`

is essentially an else statement. So, if the command is a `9`

(or, frankly, anything but a `6`

), it does the mod 127, `P`

rint ASCII, and reset `a`

to zero stuff. All we have left is `[la1+saq]sA`

, which is macro `A`

, doing nothing but incrementing `a`

.

```
66666666666666666666666666666666666666666666666666666666666666666666666696666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666696666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666669666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666696666666666666666666666666666666666666666666696666666666666666666666666666666696666666666666666666666666666666666666666666666666666666666666666666666666666666666666669666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666966666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666696666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666669666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666696666666666666666666666666666666669
0sa[10~rdZ1<P]dsPx[6=Ala127%P0sa]sR[la1+saq]sA[lRxz0<M]dsMx
Hello, World!
```

## Antiquine

,A quine is a program that does nothing but output its own source code. In various programming challenges (notably, on PPCG) the word is often generalized to refer to those which are *somehow* related to this behavior – print the source code backward, input *n* and print *n* copies of the source, etc. An interesting challenge from 2013 floated to the top of PPCG ~~this week~~ a few weeks ago (I’ve been sitting on this post for a while), Print every character your program doesn’t have. While I don’t particularly feel the need to dive into everything I attempt on PPCG, this was a very interesting challenge in how seemingly trivial decisions that appear to shrink the code could have very well ended up growing it.

The premise was, for the printable ASCII set, print every character *not* present in your source code. In `dc`

, the sort of baseline solution to beat is one which simply contains and comments out every single printable ASCII character, `# !"$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~`

– 95 bytes. So that’s the thing to beat. Even if I couldn’t beat it, I’m not sure I would have submitted that – it’s just so boring^{1}. My strategy was to:

- Use as few characters as possible in order to
- Print every character from the ASCII printables unless
- It’s in a prepopulated list of characters used in the code

The program, then, starts by pushing a list of ASCII code points that we need to exclude onto the stack, which I’ll get to after the fact. The meat of the program is `[l.dP]s;34s.[dl.!=;s,l.1+ds.127>/]ds/x`

. This defines two macros, `;`

and `/`

and runs `/`

(as `main`

essentially). Originally I had thought I would name all of my registers (macros included) with characters otherwise already used in the code, so as to not add bytes to the exclusion list. But because I (probably) needed every digit between 0 and 9, my list was already going to be partially incrementally generated, and since I needed `>`

and `<`

which are just a few code points away from `9`

, it was actually beneficial to introduce the ‘missing’ characters into the code to factor more into the incremental generation process. Theoretically, I could comment out some of these characters, but then I’d have to add the comment character, `#`

to the list as well.

The macro `/`

is rather straightforward. It duplicates top of stack, compares it to the counter `.`

, runs the printing macro `;`

if they don’t match, ‘drops’^{2} the top of stack (which has an extra value on it if `;`

ran), increments the counter `.`

, and continues running as long as we’re still below 127. The macro `;`

does nothing save for printing the ASCII value of `.`

and leaving some padding on the stack – since `/`

always deletes an item from the stack, we want it to be unimportant unless it’s removing an item from the list of exclusions.

Our list of exclusions is `120d115 112 108 100 93 91 80 62[d1-d48<:]ds:x45 43`

. We’re printing from low to high, so we make sure that from top to bottom, the stack is also arranged low to high. Since we compare our current ASCII value to this list of exclusions every time, we need to make sure there’s always *something* on the stack to compare to, so our largest/last value is duplicated. There’s a little decrementing macro in there to automatically push every value from 62 to 48 – the digits 0-9 as well as the aforementioned nearby characters that I used for macro names, etc. I tried generating the list in a handful of different bases – either to reduce bytes with fewer digits or to reduce exclusions with fewer possible numerals. In every case, the code to switch bases plus the overhead of adding that command to the exclusions list made it longer than simply using decimal.

This was an interesting challenge, one that I didn’t readily think I could beat the straightforward solution to. Many of the things that worked in my favor were counterintuitive – like introducing *more* characters that I had to exclude.

## Bubble sort in dc

,`dc`

offers essentially nothing in the way of stack manipulation. Part of the power behind a lot of RPN/RPL HP calculators was that if you were being tidy with your stack, you rarely had to use registers. This is not the case with `dc`

. Of course there’s also nothing resembling array sorting in `dc`

, and I was curious how difficult it would be to implement a basic bubble sort.

As mentioned, we can’t directly manipulate stack elements (beyond swapping the two topmost values), but we can directly address elements of an array. This means that our bubble sort needs to dump the contents of the stack into an array, and potentially dump this array back onto the stack at the end (depending on what we need the sort for).

```
zsa0si[li:sli1+dsila>A]dsAx
```

This takes care of putting everything on the stack into array `s`

. It does this by storing the number of items on the stack into register `a`

(which we will need later – `dc`

does not have a means of counting the number of items in an array). We start counter `i`

at zero, and just go one at a time putting the top-of-stack into array `s`

at index `i`

until `i`

is equal to `a`

.

```
[1si0sclSxlc1=M]sM
```

The bubble sort itself requires three macros. This first one, `M`

is our main macro, which we will ultimately begin executing to start the sort process. It sets a counter, `i`

to one and a check register, `c`

, to zero. Then it runs our next macro, `S`

, which does one pass through the array. If `S`

has changed anything by running macro `R`

, the check register `c`

will no longer be zeroed out, so we test for this and restart `M`

until no changes have been made.

```
[lidd1-;sr;s<R1+dsila>S]sS
```

As mentioned, macro `S`

does one pass of the array `s`

. We fetch our counter, `i`

, duplicate it twice, and decrement the top copy by one. While we work on our array, we’re always looking at `i`

and `i-1`

essentially, which just makes the comparison a bit tidier at the end vs. `i+1`

and `i`

. We load the values with these indices from `s`

, compare them, and if they aren’t in order, we run macro `R`

. We still have a copy of `i`

on the stack at this point, so we increment it, duplicate it, store it, and compare with `a`

to see if we’ve hit the end of the array.

```
[1scddd;sr1-;sli:sr1-:s]sR
```

Macro `R`

does one instance of reversal. First it puts a one in the check register, `c`

, so that `M`

knows changes have been made to the array. At this point there is still a copy of `i`

on the stack, which we duplicate three times. We load the `i`

-indexed value from `s`

, swap with a lower copy of `i`

which we decrement by one before loading this `i-1`

-indexed value from `s`

. We load `i`

again, and store the old `i-1`

value (our previous top-of-stack) at this index. This leaves our old `i`

value atop the stack, with `i`

one spot below it. We swap them, subtract one from `i`

, and store the old `i`

value at this new `i-1`

index in array `s`

.

And that’s actually it. If we populate the stack and run our initial array-populating code before executing `lMx`

, we’ll end up with our values sorted in array `s`

. From here, we can `[li1-d;srdsi0<U]dsUx`

to dump the array onto the stack such that top-of-stack is low, or `0si[lid;sr1+dsila>V]dsVx`

to dump the array onto the stack such that top-of-stack is high. If, say, we only need min (`0;s`

) or max (`la1-;s`

), these are simple tasks.

Additionally, if we wanted to get the median of these values, we can exploit the fact that `dc`

just uses the floor of a non-whole index into an array. This allows us to avoid an evenness test by always taking ‘two’ values from the middle of the array and calculating their mean. If `a`

is odd, then half of `a`

will end in `.5`

. Conversely, if `a`

is even, half of `a`

will end with no remainder. So we can subtract half of `a`

by `.5`

to get the lower bound, and then subtract half of `a`

by half of `a`

mod one (either `.5`

or `0`

) and average the values at the resulting two indices: `la2/d1~-;sr.5-;s+2/p`

.

## Nth-order Fibonacci sequence in dc

,After working on the nearest Fibonacci number problem in `dc`

, I got to thinking about how one might implement other generalized Fibonacci sequences in the language. *N*th-order sequences seemed like a fun little challenge, and since I was simply doing it for my own pleasure I went ahead and gave it prompts and user input:

```
% dc -e '[_nacci? ]n?1-sg[terms? ]n?2-snlgsi[0lid1-si1<Z]dsZx1[dls+ssli:flid1+silg>G]sG[li;flid1-si0<R]sRlgsz[0si0sslGxlgsilRxlslzd1+szln>M]dsMxf'
_nacci? 4
terms? 20
20569
10671
5536
2872
1490
773
401
208
108
56
29
15
8
4
2
1
1
0
0
0
```

…gives us the first 20 terms of the tetranacci sequence. This interested me because unlike a simple Fibonacci iteration that can be handled on the stack with only rudimentary stack manipulation (`dsf+lfr`

), higher order ‘naccis need summation of more terms. For a defined number, I could simply use registers, but `dc`

does support arrays, so setting the order at runtime is plausible. There’s a bit going on here, so I’m going to start by rattling off all of the registers I use:

- g:
- The order (so, a
*g*-nacci sequence) - n:
- Number of terms to run through
- s:
- Sum
- i:
- General counter
- f:
- Array used to temporarily hold the last sequence as it’s being summed
- G:
- Generalized Fibonacci generating macro
- R:
- Macro to retrieve previous sequence from f
- Z:
- Zero-seed macro
- z:
- Counter for iterations (compares to n)
- M:
- Main macro

Now to break down what’s going on. `[_nacci? ]n?1-sg[terms? ]n?2-sn`

just prompts the user and inputs `g`

and `n`

. We reduce each of these in the process to appease the loops. After doing this, we need to seed the sequence with `g-1`

zeroes, and one one. `lgsi`

sets counter `i`

to `g`

, and then the macro `Z`

, does nothing but put a zero on the stack and loop: `[0lid1-si1<Z]`

^{1}. `dsZx`

stores the macro and executes it; then `1`

pushes the necessary one onto the stack such that we can begin.

`[dls+ss]sS`

is our macro, `S`

, which is a simple summer for register `s`

. It duplicates the top of stack, recalls `s`

, adds the two together, and then writes that back to `s`

. The stack is returned to its original state.

Our next macro, `G`

, has a bit more going on: `[dls+ssli:flid1+silg>G]sG`

. It starts with a simple summer for register `s`

, `dls+ss`

. This duplicates the stack, recalls `s`

, adds them and then overwrites `s`

with the new sum. The stack returns to its original state. The next thing we need to do is move the top of the stack into our holding array, `f`

. We’ll use our counter `i`

as an index, so we load `i`

and then do the array operation, `li:f`

. Every time we do these two things, our summation (the next number in the sequence) nears its next value, and our stack shrinks. The rest of the macro, `lid1+sig>G`

just handles incrementing `i`

and comparing it to our order, `g`

, determining whether or not to continue the loop.

Macro `R`

, `[li;flid1-si0<R]sR`

repopulates the stack from array `f`

. Before calling `R`

, `i`

is set to `g`

, and we use that as our array index to pull from, thus treating the array as a LIFO^{2}. `li;f`

does this, and then the rest of the macro is (surprise, surprise) counter/loop handling.

Before we run macro `M`

, which is our main macro essentially, we set counter `z`

to our order number `g`

, which accounts for the fact that we already have our first few terms in assorted zeroes and a one. `M`

, `[0si0sslGxlgsilRxlslzd1+szln>M]dsMx`

, starts out by resetting counter `i`

and the sum register `s`

to zero: `0si0ss`

. `lGx`

runs macro `G`

, `lgsi`

sets counter `i`

to our order `g`

, and then `lRx`

runs macro `R`

. `ls`

puts our sum (the new Fibonacci value) at the top of the stack, and then the rest of the thing is counter/loop handling. `dsMx`

saves the macro as `M`

and also sets it running, while our last command, `f`

prints the entire stack.

## 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
```

## Arbitrary precision

,I use `dc`

as my day-to-day computer calculator because it’s RPN, it’s there, and I know its language. But as I was watching this Numberphile video from a few years back on the ^{1}⁄_{998001} phenomenon, I remembered that `dc`

is capable of arbitrary precision. I don’t think about this much, because it’s rare that I actually need 3000 digits of precision, generally I just sort of start my session with `4k`

so I know I’m getting *something* past the point. It was fun, however, to run `dc -e '3000k1 998001/p'`

and see a full cycle of its repeating decimal instead of something like 1.002003004×10^{-6}.

## Collatz sequences in dc

,Inspired by this recent post and code snippet by John Gruber, I decided to have a go at outputting Collatz conjecture sequences in `dc`

. Running

```
dc -e '?[r3*1+]so[d2~1=opd1<x]dsxx'
```

from the command line will take a single value as input, and run the sequence.
`?`

takes input, puts it on the stack. `[r3*1+]so`

is our macro for *n3+1*, what we do when we encounter an odd value. `[d2~1=opd1<x]dsxx`

is our main macro, as well as our macro for handling even numbers (*n/2*). First it duplicates the value on the stack (last iteration) and divides by 2 to return the quotient and the remainder. `1=o`

uses the remainder to test for oddness and run `o`

if true. Here I do something rather lazy for the sake of concise code: that initial duplication was solely for the sake of oddness. `o`

swaps the top of the stack to get that value back, then multiplies by three and adds one, leaving this value on the stack. Evenness will never run this, and since the test for evenness leaves the outcome for evenness on the stack (what luck!), and the initial duplication is below it. Either way, the bottom of the stack is going to fill up with a lot of garbage, which should be inconsequential unless our sequences become absurdly long. At this point, the top of our stack is the result of the current step, so we `p`

rint it, `d`

uplicate it, and run `x`

if it’s greater than 0. Finally, we `d`

uplicate our main macro, `s`

ave it as `x`

, and then e`x`

ecute the copy we left on the stack.

## dc as a code golf language

,Code golf is a quirky little game – complete the challenge at hand in your preferred programming language in as few bytes as possible. Whole languages exist just for this purpose, with single-character commands and little regard for whitespace. `dc`

always seemed like a plausible language for these exercises, and I recently attempted a few tasks which I would not ordinarily use dc for, notably 99 Bottles of Beer.

## dc

,Even though I generally have an HP or two handy, the POSIX command-line RPN calculator, `dc`

, is probably the calculator that I use most often. The manpage is pretty clear on its operation, albeit in a very manpagish way. While the manpage makes for a nice reference, I've not seen a friendly, readable primer available on the program before. This is likely because there aren't really people lining up to use `dc`

, but there are a couple of compelling reasons to get to know it. First, it's a (and in fact, the only calculator, if memory serves) required inclusion in a POSIX-compliant OS. This is important if you're going to be stuck doing calculations on an unknown system. It's also important if you're already comfortable in a postfix environment, as the selection of such calculators can be limiting.

## dc Syntax for Vim

,I use dc as my primary calculator for day-to-day needs. I use other calculators as well, but I try to largely stick to dc for two reasons - I was raised on postfix (HP 41CX, to be exact) and I'm pretty much guaranteed to find dc on any *nix machine I happen to come across. Recently, however, I've been expanding my horizons, experimenting with dc as a programming environment, something safe and comfortable to use as a mental exercise. All of that is another post for another day, however - right now I want to discuss writing a dc syntax definition for vim.