Acc!!
Acc!! is a Turing tarpit built on unbounded integer math, loops, and a single accumulator.
Language description
Acc!! is an imperative programming language. The syntax is designed to be fairly readable; the main challenge is the semantics.
Expressions
All values in Acc!! are unbounded integers. They can be combined in arbitrarily complex expressions using the following infix operators:
+, addition-, subtraction; unary negation*, multiplication/, integer division%, modulo^, exponentiation
An expression can include integer literals, loop counter variables (a-z), the accumulator variable _, and the special value N, which reads a character from stdin and returns its character code each time it is used. Parentheses can be used to enforce precedence of operations. Any other character in an expression, other than whitespace, is a syntax error.
Statements
Acc!! contains three types of statements:
Bare expression
Any expression standing by itself is evaluated and assigned to the accumulator (which is accessible as _). Thus, 3 is a statement that sets the accumulator to 3; _ * 2 multiplies the accumulator by 2; and N % 48 reads a character and sets the accumulator to its character code mod 48.
The accumulator is the only variable whose value can be set directly; loop variables and N can be used in calculations but not modified.
The accumulator is initially 0.
Write statement
Write expr
Outputs a single character with the given ASCII/Unicode value to stdout. The character code expr can be any expression.
Count-while loop
Count var while expr {
}
Sets var to 0 and loops while expr is nonzero, incrementing var after each iteration. Equivalent to for(int var = 0; expr; var++) in C-like languages (but with unbounded integers). The loop counter var can be any single lowercase letter a-z. The condition expr can be any expression, not necessarily involving the loop counter. Loop counter variables are only available inside their loops; attempting to reference them afterwards causes an error.
Input and output
Each time N is referenced in an expression, Acc!! reads one character from stdin. (This means you only get one shot to read each character; the next time you use N, you'll be reading the next one.) N evaluates to the character code of the character. In the official Python interpreter, each line of input (including the last) is terminated with a newline (character 10). Once end-of-file has been reached (e.g. if stdin was redirected from a file or if the user enters an EOF manually), N evaluates to 0 for the rest of the program.
A character can be output to stdout by passing its character code to the Write statement.
Whitespace and comments
Leading and trailing whitespace and empty lines are ignored. Loop headers must be formatted exactly as shown above, including a single space between the loop header and opening curly brace. Whitespace inside expressions is optional.
# begins a single-line comment.
History
Acc!! was created by User:Dlosc for the challenge Create a programming language that only appears to be unusable on Code Golf StackExchange. The initial version was called Acc!; however, because it allowed loop counters to be referenced after their loops completed, it turned out to be too usable. This led to the creation of the second version.
Examples
Hello, world!
Write 72 Write 101 Write 108 Write 108 Write 111 Write 44 Write 32 Write 87 Write 111 Write 114 Write 108 Write 100 Write 33
Truth-machine
N
Write _
Count i while _/49 {
Write _
}
Convert a string to lowercase
N
Count i while _ {
Write _ + (_/65)*(90/_)*32
N
}
Find the highest unique digit in a number
We conceptually partition the accumulator into two sections: _%81 stores the most recently read character, while _/81 stores ten counters, one for each digit, denoting whether that digit has occurred 0, 1, or 2+ times. For example, an accumulator value of 3214945 (20001100002001 in base 3) represents the following:
Occurrences of Next character 9 8 7 6 5 4 3 2 1 0 ------------------- -------------- 2 0 0 0 1 1 0 0 0 0 7 (character code 55, or 2001 in base 3)
When a digit occurs more than 2 times, we cap its occurrence count at 2. Then once all digits have been processed, the answer is the highest digit that has 1 as its occurrence count.
### Part 1: read the input and count digit occurrences
# Read the first character into the accumulator
N
# Loop while the most-recently-read character was a digit (>= charcode 48):
Count i while _%81/48 {
# The digit we just read is _%81-48
# Its occurrence count is (_/81)/3^(_%81-48)%3
# We add 1 to the occurrence count; but if the occurrence count was already 2,
# we also subtract 1, leaving it unchanged
_ + (1 - ((_/81)/3^(_%81-48)%3) / 2) * 81 * 3^(_%81-48)
# Clear out the previously read character and read a new character
_ - _%81 + N
}
### Part 2: output the highest unique digit
# Count up i, starting at 0, until the accumulator gets zeroed out
Count i while _ {
# 9-i is the current digit
# Its occurrence count is (_/81)/3^(9-i)%3
# Loop if the occurrence count is odd (i.e. 1, not 0 or 2):
Count j while ((_/81)/3^(9-i)%3) % 2 {
# Output that digit
Write (9-i) + 48
# Zero out the accumulator, causing both loops to end
0
}
}