• Fibonacci:
  Starts at 0,1 and goes until it overflows, then either resets or halts. Score for big will be calculated with the average tick per iteration of fib. This example does 2 iterations per loop, so you would count the total length of the loop, (lines 3-9) which is 6 cycles, so given a 10 tick clock you would spend 60 ticks in the loop, with 2 iterations per loop, that gives you a score of 30 ticks. Example:
  

1. Clear your Registers
   
2. Load an Immediate of 1 into register A 
   
3. #START
   
4. Add Register A with Register B
   
5. Branch to #OVERFLOW If_Cout
   
6. Add Register B to Register A 
   //Option 1:
   
7. Branch to #OVERFLOW If_Cout
   
8. Jump to #START
   //Option 2:
   
9. Branch to #START If_NOT_Cout
   
10. not needed
    #OVERFLOW//with halt:
    
11. Halt
    //with reset:
    
12. Jump to Line 1
    

• Sequential Squares:
  Find the Squares of the numbers 1-4 for 4 bit CPUs and 1-8 for 8 bit CPUs. Optional challenge: store squares in there respective roots RAM address (Such, 1^2 would be stored in RAM address 1, 2^2 would be stored in RAM address 2, 3^2 would be stored in RAM address 3.Example: (does not show the storing to RAM, HINT: use your A register as a RAM Pointer). Scoring for this program will be nearly the same as fib, average ticks per iteration. This example has 1 iteration per loop. So given the following example, we have the loop running from lines 5 to 9. That is 5 total cycles, if we again use a 10 tick clock, this program would have a score of 50 ticks. Example:
  

1. Clear registers
   
2. Load an Immediate of 1 into Register A
   
3. Add Register A to Register B store to Register B
   
4. Add Register A to Register C store to Register C
   //#START of loop, 1^1 is now in B.
   
5. Add Register A to Register B store to Register B
   
6. Increment Register A
   
7. Increment Register C 
   
8. Add Register C to Register B Store to Register B
   
9. Jump to #START
   

• List Comparison:
  Compare the contents of 2 Lists. [9,8,2,5,9,1,1,2] and [9,8,2,5,9,0,1,2]. I will give 3 separate examples for this one. Two with a CPU that has 16 bytes of RAM or more, both with and without pointers. One that does not require RAM but does require a bit more instruction memory as the same lists will be contained in a series of Load Immediate instructions rather than load from RAM. The score on this will be similar to the rest, avg number of ticks per pair of elements compared. Instructions that are *'ed are only needed if your using pointers for Load/Store, Pointers also require 5 registers compared to 3 without... Example:
  With RAM Load/Store Poiners:
  

1. Preload your RAM if you have at least 16 bytes. with the following numbers in order from address 0 in RAM to address 15: 7, 8, 3, 5, 9, 1, 1, 2, 9, 8, 2, 2, 9, 0, 1, 2. You may do this preload by hand and put the data in manually into your RAM or use a PROM for this if you want to just read from it. Or any other way you like. 
   
2. Clear Registers
   
3. Load an immediate of 8 into Register B
   
4. Load an Immediate of 8 into Register C
   
5. #START
   
6. Subtract/Compare Register C from/with Register A (Do not store Result)
   
7. Branch to #CHECKED if C and A came back Equal (If0+!Cout... you don't really need the !Cout for this particular case tho)
   
8. Load @A (Register A as a pointer) to Register C 
   
9. Increment Register A
   
10. Load @B (Register A as a pointer) to Register D
    
11. Increment Register B
    
12. Subtract/Compare (same thing) Register C from D
    
13. Branch to #START If C and D came back Equal
    
14. Halt or end or something.
    
15. #CHECKED
    
16. Halt or end or something different.
    

• Without RAM Load/Store Pointers or with Load Immediates:
  

(05-24-2017, 08:56 PM)LordDecapo Wrote: <placeholder thread till the full one is written>

post here with a simple "i accept the challenge" if you would like to be in the build-off this Saturday 11am-5pm EST. 
You may premake your IS, design your arch, and make an ALU... ANYTHING other then that must be complete in the 6hour window saturday on the competition plot.