Node 0 contains all the logic. The program switches between different states (no zeros, one zero, and two or more zeros) instead of counting consecutive zeros by incrementing a register.
The Signal Pattern Detector was originally segment 40633, and the sequence to be detected was 1, 5, 4. Here is the code for node 0 in this version:
START: JRO UP
ONE: MOV -99 ACC
TWO: NOP
THREE: JMP NOPE
FOUR: JMP LBL4
FIVE: ADD 99
JNZ NOPE
MOV 125 ACC
JMP NOPE
LBL4: SUB 125
JNZ NOPE
MOV 1 RIGHT
JMP START
NOPE: MOV 0 RIGHT
Node 8 calculates the minimum value by comparing each input to the smallest value it has seen so far (or to 999 for the first value in a sequence). Two copies of each input are used. The second copy is either stored as the new minimum value or used to restore the previous minimum (ADD UP saves several cycles over MOV UP NIL / SWP / SAV).
Node 9 calculates the maximum value similarly.
Node 5 saves a zero to the empty stack, so it can detect the “bottom” of the stack without having to keep track of the number of values on the stack. Node 5 reads input values and pushes them onto the stack until it receives a zero, then pops values off the stack and sends them to the output until it sees a -1 again.
The terminating zero in each input sequence gets written to the stack and then immediately discarded. This is still faster than checking whether the input is zero every time before writing it to the stack, like this:
FWD: MOV LEFT ACC
JEZ REV
MOV ACC UP
JMP FWD
REV: # ...
In general, it’s faster to write loops that have only one conditional jump at the very end of the loop, and that just continue to the next part of the program when the loop is finished. We add one instruction after the loop, but make the body of the loop (which is executed many times) one instruction shorter:
FWD: MOV LEFT ACC
MOV ACC UP
JGZ FWD
MOV UP NIL
REV: # ...
Optimized by CaitSith2.
Node 1 makes each input sequence exactly 6 values long by adding -1s to the end, and removes the trailing zero.
Node 5 reads in a sequence of exactly 6 values from LEFT, then outputs the same sequence in reverse order to DOWN, followed by a 0. Three of the values are stored temporarily in node 6.
Node 7 passes values from node 5 to the output, discarding all -1s that were added by node 4.
Solution by gmnenad.
Nodes 1 and 4 save each sequence of numbers to the Stack Memory Nodes, alternating between the upper node (during the loop labeled S) and the lower node (during the loop labeled S2).
Nodes 5 and 7 read each sequence of numbers from the Stack Memory Nodes and write them to the output.
Each node passes a -1 to the other nodes when it finishes filling or emptying a stack.
Nodes 1 and 2 are reused from Sequence Generator, and determine which is larger between IN.A and IN.B.
Node 5 stores the larger input in BAK, and passes a sequence to node 7 with length equal to the smaller input.
Node 7 is reused from Sequence Counter, and calculates the sum of each sequence to give the result of the multiplication.
Solution by CaitSith2.
Node 2 passes IN.A to node 5, followed by two copies of 10 - IN.B.
Node 5 stores IN.A in ACC and passes one copy of 10 - IN.B to node 7, followed by a sequence of IN.A repeated IN.B times. Instead of decrementing a loop counter, the JRO instruction is used to unroll the loop by starting with a sequence of 10 MOV ACC DOWN instructions and skipping the first 10 - IN.B.
Node 7 starts with zero in ACC and uses the copy of 10 - IN.B passed from node 5 to count how many times to add IN.A. After writing the result to OUT, ACC is reset to zero.
Solution by CaitSith2.
Node 2 compares IN.A and IN.B as in the naive solution, and passes the larger value first to minimize the number of repeated additions. Nodes 5, 6, and 7 in this solution (with some additional plumbing in node 4) are equivalent to nodes 2, 5, and 7 in the size-optimized solution.
Optimized solution by CaitSith2.
This is a commonly used algorithm for multiplying two numbers, similar to the pencil-and-paper “long multiplication” taught in elementary schools.
Nodes 1 and 4 calculate the binary representation of IN.A (with 3 representing a binary one and 1 representing a binary zero) and pass it, most significant bit first, to node 5.
Node 5 uses the binary value of IN.A to determine when to pass a copy of IN.B to node 7 and when to pass a zero value.
Node 7 sums up the values from node 5, shifting ACC one bit to the left (i.e. multiplying it by 2) after each step.