Termination
Here are 3 programs that print the numbers 1-100 using different termination strategies:
This program uses a straightforward conditional branch into an @.
. . . . . . .
. . . . . . . .
. . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . _ . . .
) ! { Ċ ; d ' : < > . { =
. . . . . . . . @ . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . .
. . . . . . . .
. . . . . . .
This program uses the # operator, which is a no-op when the current memory cell is zero, but otherwise can change the instruction path.
. . . . . . .
. . . . . . . @
. . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . . .
) ! { Ċ ; d ' : . # . { =
. . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . .
. . . . . . . .
. . . . . . .
This program exits via division by zero error. This has the advantage of not requiring any branching or control flow operators to terminate.
. . . . . . .
. . . . . . . .
. . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . . . .
) ! { Ċ ; d ' - ' : } { =
. . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . .
. . . . . . . .
. . . . . . .
Note that the first 2 programs work by redirecting control flow onto a path with an @ on it. But with careful adjustment, or just luck, the path the IP is redirected on may happen to run into a division by zero. For example, here's a slight modification on the first program that reuses the division operator to terminate:
. . . . . . .
. . . . . . . .
. . . . . . . . .
. . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . _ . . .
) ! { Ċ ; d ' : < > . { =
. . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . .
. . _ . . . . .
. . . . . . .
Here is a program that prints all arguments separated by newlines and then exits with a div by zero error. It uses the fact that all arguments are zero-byte-terminated, and after all args are exhausted, reading a byte yields -1.
. . . . . .
. . . . . . .
. . . . . . . .
. . . . . . . . .
. > ) ' : } Ċ ; \ .
, < > ; . . . $ \ . .
. _ . . . . . . . .
. . . . . . . . .
. . . . . . . .
. . . . . . .
. . . . . .
Powers of ten
Exponentiation can be useful in Hexagony, and powers of ten are particularly nice since multiplying a cell by ten can be accomplished by just using the 0 operator on the cell. Here is an exponentiation "subroutines" that can be called from the main IP with ], multiplying one cell adjacent to the cell it is called on n by 10**n:
. . . . . / $ >
. . . . . . > < $
. . . . . . \ [ / .
. . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . . . .
} 0 . \ . . . . . . . . . . .
( ' < . . . . . . . . . . .
. . . . . . . . . . . . .
. . . . . . . . . . . .
. . . . . . . . . . .
. . . . . . . . . .
. . . . . . . . .
. . . . . . . .
It can also become 100**n by adding an extra zero in the empty slot.
Data Structures
Like brainfuck, Hexagony is a registerless language where all data structures have to be built into memory from scratch. However, in contrast to brainfuck, moving through memory is arguably even more cumbersome, and cells can store arbitrarily large integers. Because of this, it is often feasible to store entire data structures in a single cell. Here is an example in Python 3 of what creating a stack stored entirely inside a single integer might look like.
class HexagonyStack:
def __init__(self, size = 256):
self.stack = 0
self.cellSize = size
def push(self, val):
self.stack = self.stack * self.cellSize + val
def pop(self):
temp = self.stack % self.cellSize
self.stack //= self.cellSize
return temp
def peek(self, index):
return self.stack // (self.cellSize ** index) % self.cellSize
HXS = HexagonyStack(100)
HXS.push(20)
HXS.push(30)
print(HXS.peek(1)) # 20
print(HXS.pop()) # 30
print(HXS.pop()) # 20
print(HXS.pop()) # 0
It is notable that this type of stack by default has an infinite number of zeroes at the bottom.
Cell sizes that are powers of ten are often the best for golf since multiplication by ten takes a single operator, and powers of two seem to aid performance.
Although data stored like this takes some math just to interface with it, it may often still be shorter than trying to manage the data pointer across a complex memory structure.