I spent a few hours trying to fit in the recursive version of Towers of Hanoi (e.g., see here: https://www.cs.cmu.edu/~cburch/survey/recurse/hanoiimpl.html):

FUNCTION MoveTower(disk, source, dest, spare):
IF disk == 0, THEN:   
  move disk from source to dest
ELSE:    
  MoveTower(disk - 1, source, spare, dest)   
  move disk from source to dest              
  MoveTower(disk - 1, spare, dest, source)  
END IF

Previously, I succeeded doing this for the Microtronic - the Microtronic doesn't offer a native stack, nor programmatic access to the RAM! RAM is only for program memory (-> Harvard Architecture), and writable memory is register memory only. So implementing a stack for recursion is not so straight forward, but it is possible by shifting its set of 16 "extra registers" up and down to emulate push and pop operations to a stack (altogether, the Microtronic has 2x 16 4bit registers):

Also, there are no computed or "indirect" jumps - it is not possible to put a return address in a register (or memory) location and simply jump "indirectly" to the address stored there.

Hence, I used numeric jump labels and something I called a "jump block" - to do a computed jump (i.e., a return from a recursive call or subroutine to a variable address), I am comparing a register that I  set up to act as "return" register to these numeric jump labels and execute conditional jumps  accordingly. 

Putting the 2 techniques together I was then able to implement both a value and a return stack and hence could execute the recursive version of the towers of Hanoi for up to n=4 disks; you can find the Microtronic program here to get the idea: https://github.com/lambdamikel/picoram2090/blob/main/software/1.1/HANOI.MIC

Would the same techniques work for the Science Fair? In particular, since the Science Fair offers indexed memory access - load & store to the data region from 0x50 - 0x5F via the Y "index" register is possible, using the op-codes `AM (4)` and `MA (5)`, I though at least the stack implementation should be much more straight forward: 

4 | AM | 4 | M(Y) <- A
5 | MA | 5 | A <- M(Y)

And indeed, using the Y-register as index into the data region, and being able to do "stack arithmetics"  using the `AIY (B)` op-code

B | AIY n         | B n        | Y <- Y + n

worked like a charm - much more straight-forward than on the Microtronic!

Like with the Microtronic, "computed" jumps to computed target addresses stored in memory or a register are impossible, so I require the same "jump block" mechanism for the Science Fair as well.

Unfortunately, I ran out of program space on the Science Fair - I would have needed exactly 15 more nibbles! My program overlaps with the data region (from 0x50 on) that I would need for the (value and return) stack - but in principle, the ideas are sound, and it should work (if I only had more space...) 

But here is the program so far: 

// CONCLUSIONS - DOESN'T HAVE ENOUGH MEMORY :-(
// JUMP BLOCK OVERLAPS DATA REGION (50... ) 

//
// Towers of HANOI on the Science Fair Microcomputer Trainer
// (C) 2024 by LambdaMikel
//
// Memory and registers need to be set up manually:
// 
// 1. Load n = 1, 2, 3, 4 into B (@ 6C) 
// 2. Point Y (@ 6E) to 53 
// 3. Load Label 0 into 53 
//
// 4. Set up first stack frame by hand: 
// 50 = SOURCE : A
// 51 = DEST   : C
// 52 = SPARE  : B 
// 53 = RET    : 0
//
//
// MoveTower(n, source, dest, spare) 
//

00 2  CH     GET n value from B: A <- B  
01 C  CIA 1  A <> 1 ? -> FLAG = 1, JUMP REC. CASE  
02 F  JUMP   REC CASE @ OB - JUMP executed when FLAG = 1 (A <> 1) 
03 0  
04 B 

// A = 1 
// Base case 
// Y points to RET label 

// move disk from source to dest
// no mem space for output! only n display 

05 1  A0     HEX DISP 

06 2  CH     Store n value back into B: A -> B   

07 F  JUMP   JUMP BLOCK @ 50 
08 5
09 0 

// A > 1
// Recursive case 
// Y points to RET label 

// Compute n - 1 by adding F (= Sub 1) 

0A 9  AIA F  (= SUB 1) 
0B F 
0C 2  CH     Store A = n-1 into B: A -> B 

// Prepare first recursive call:
//
// MoveTower(disk-1, source, spare, dest)
// Stack:  
//        <50,     51,   52,     53>
// Y points to 53 
// 
// SOURCE <- SOURCE
// DEST   <- SPARE
// SPARE  <- DEST

// Subtract 1 from Y, 53 -> 52 
// Load A with cur. SPARE (= 52)

0D B  AIY   Y <- Y + F (= Y - 1) 
0E F 
0F 5  MA    A <- M(Y = 52 = SPARE) 

// Store cur. SPARE into new DEST (55 = 52 + 3) 
// DEST <- SPARE 

10 B  AIY  Y <- Y + 3 
11 3 
12 4  AM   A -> M(Y = 52 + 3 = 55) 

// SPARE (56) <- DEST (51) 
// FROM 55 to 51: SUB 4 = ADD C

13 B  AIY  Y <- Y + C (= -4) 
14 C   
15 5  MA   A <- M(Y = 51 = DEST) 

// Store cur. DEST into new SPARE (56 = 51 + 5) 

16 B  AIY  Y <- Y + 5 
17 5 
18 4  AM   A -> M(Y = 51 + 5 = 56) 

// Load cur. SOURCE (50) into new SOURCE (54) 

19 B  AIY  Y <- Y + A (= -6) 
1A A 
1B 5  MA   A <- M(Y = 56 - 6 = 50) 

// Store cur. SOURCE into new SOURCE (54 = 50 + 4) 

1C B  AIY  Y <- Y + 4 
1D 4 
1E 4  AM   A -> M(Y = 50 + 4 = 54) 

// Set up new RET label 1 (1 -> @ 57 = JUMP to 28) 

1F B  AIY    Y <- Y + 3 (57 = 54 + 3) 
20 3 
21 8  TIA 1   
22 1 
23 4  AM     A -> M(Y = 57) 

// MAKE THE FIRST RECURSIVE CALL! 

24 F  JUMP HANOI -> 00 
25 0 
26 0 

// Returned: inc. n and pop stack 
// Add 1 TO B 

27 2  CH   B <- A 
28 9  AIA  A <- A + 1 
29 1 

// OUTPUT for MOVE disk n from source to dest 

2A 1  A0  HEX DISP 

2B 2  CH  A -> B

// Pop stack frame 

2C B  AIY  Y <- Y + C (= -4) 
2D C 


// Prepare second recursive call:
//
// MoveTower(disk-1, spare, dest, source)
// Stack:  
//        <50,     51,   52,     53>
// Y points to 53 
// 
// SOURCE <- SPARE
// DEST   <- DEST
// SPARE  <- SOURCE 

// SOURCE (54) <- SPARE (52) 

// Load SPARE (52)

2E B  AIY  Y <- Y + F (= Y - 1) 
2F F 
30 5  MA   A <- M(Y = 52) 

// Store SOURCE (54)

31 B  AIY  Y <- Y + 2 
32 2 
33 4  AM   A -> M(Y = 52 + 2 = 54)

// DEST (55) <- DEST (51) 

// Load DEST (51)

34 B  AIY  Y <- Y + D (= -3) 
35 D 
36 5  MA   A <- M(Y = 54 - 3 = 51) 

// Store DEST (55)

37 B  AIY  Y <- Y + 4 
38 4 
39 4  AM   A -> M(Y = 51 + 4 = 55) 

// SPARE (56) <- SOURCE (50) 

// Load SOURCE (50) 

3A B  AIY  Y <- Y + B (= -5) 
3B B 
3C 5  MA   A <- M(Y = 55 - 5 = 50) 

// Store SPARE (56) 

3D B  AIY  Y <- Y + 6  
3E 6 
3F 4  AM   A -> M(Y = 50 + 6 = 56) 

// Set up new RET label 2 (2 -> @ 57 = JUMP to 4A)

40 B  AIY    Y <- Y + 1 (57 = 56 + 1) 
41 1 
42 8  TIA 2   
43 2 
44 4  AM     A -> M(Y = 57) 

// MAKE THE SECOND RECURSIVE CALL! 

45 F  JUMP  HANOI -> 00
46 0 
47 0 

// Returned: inc. n and pop stack 
// Add 1 TO B 

48 2  CH   B <- A 
49 9  AIA  A <- A + 1 
4A 1 
4B 2  CH   A -> B 

// Pop stack frame 

4C B  AIY  Y <- Y + C (= -4) 
4D C 

// Return via JUMP  = 50 
// REDUNDANT! just keep going... 

//
// JUMP BLOCK 
// Label 0, 1, 2 
//

4E 5  MA     A <- M(Y = STACK) 

4F C  CIA 0  (<> 0 ?) 
50 0 
51 F  JUMP   59 
52 5 
53 9
54 F  JUMP   56, ENDLESS LOOP for Label 0 
55 5 
56 6

57 C  CIA 2  (<>2 ?) ->  LABEL 1
58 2  
59 F  JUMP    = 28 
5A 
5B  

5C F  JUMP LABEL2 
5D  
5E