Conundrums, Puzzles, and Posers

The Problem: Generating the Even-Parity Bit for a Byte Parity bits provide the simplest form of error-checking codes. There are two types of parity: even parity and odd parity. In the case of even parity, an extra parity bit is set to 1 if the number of ones in a given set of bits is odd, thereby resulting in the total number of ones being even.

OK, here's the problem, assume that the DIY Calculator's 8-bit accumulator is loaded with some unsigned binary value between %00000000 and %11111111 (where the '%' characters indicate binary values). We want the least-significant bit of the accumulator to end up containing the even parity bit associated with this byte. For example, if the accumulator starts off containing a value of %00110111 (an odd number of 1s), then we want it to end up containing %00000001; but if it started off containing say %00110110 (an even number of 1s), then we want it to end up containing %00000000.

Your mission is to create two programs in the DIY Calculator's assembly language that perform this task: (a) using the least number of instructions and (b) using the smallest amount of memory.

Getting Started This section is intended to set some ground rules to ensure that we're all playing on a level field. If you haven’t already done so, download the latest version of the DIY Calculator from the "Downloads" page on the www.DIYCalculator.com website (this page also provides installation instructions). Following installation, double-click the DIY Calculator icon on your desktop:

Next, use the Tools > Workbench #1 command to access the DIY Calculator's simple workbench interface containing switches, LEDs, and other displays (this is much more appropriate for this type of problem than the main interface):

The two banks of 8-bit switches are connected to two of the DIY Calculator’s input ports; meanwhile, the 8-bit LED display and the three different flavors of 7-segment displays are connected to four of the DIY Calculator’s output ports as follows: Port Type Port Address I/O Device Input $F000 8-bit Switch Bank #1 Input $F001 8-bit Switch Bank #2

Output $F020 8-Bit LED Display Output $F021 Single Un-decoded 7-Segment Display Output $F022 Single Decoded 7-Segment Display Output $F023 Dual Decoded 7-Segment Display Drag this workbench away from the main calculator interface to an open area on your screen. Now try clicking some of the switches on one or both of the 8-bit switch banks: nothing happens (apart from the switches themselves flipping up and down), because (a) we haven’t powered our virtual computer up yet and (b) we don’t have a program to run even if the virtual computer was powered up.

Creating a Skeleton Program Our first task is to create a skeleton program. We will be able to use this program as the basis for a variety of puzzles and posers (if you've already created this program, skip to the next section). Use the Tools > Assembler command to launch the DIY Calculator's assembler:

Enter the following program into the assembler-editor:

###################################################################### # # # Skeleton program #1 for puzzles and posers # # # ######################################################################

WB_SWTA: .EQU $F000 # Input port for top bank of switches WB_LEDS: .EQU $F020 # Output port for eight LEDs .ORG $4000 # Set origin to first byte in RAM

MAINLOOP: LDA [WB_SWTA] # Load accumulator from switches ### Your code goes here STA [WB_LEDS] # Copy accumulator to LEDS JMP [MAINLOOP] # Jump back and do it all again

.END # That's all folks

As you can see, this is a very simple program whose sole purpose in life is to loop around reading a value from the upper bank of switches and copying this value to the bank of LEDs. Use the assembler's File > Save As command to save this program as puzzle-skeleton-1.asm in the DIY Calculator's \Work folder, then use the assembler's File > Assemble command to ensure that you don’t have any finger-slip errors in your code.

Creating your Own Program Use the assembler to open the puzzle-skeleton-1.asm file described in the previous section; use the File > Save As command to rename this program to puzzle-even-parity.asm; and then use the assembler's File > Assemble command to convert this program into a corresponding machine code file called puzzle-even-parity.ram. As you can see from the previous page, our skeleton program comprises only three instructions: the LDA ("load accumulator"), STA ("store accumulator"), and JMP ("unconditional jump"). But how many bytes of memory does it consume? Of course, we can calculate this by hand for such a simple program, but why make life hard on ourselves? The point is that, as soon as you've assembled a program, you can use the assembler's Window > View List File command to see how much memory it consumes. If you do this now, you'll discover that our skeleton program occupies nine bytes of memory. Before we do anything else, click the On/Off button on the calculator's front panel to power-up the DIY Calculator, and then use the Memory > Load RAM command to locate your puzzle-even-parity.ram file and load it into the DIY Calculator's memory. Now, click the Run button on the calculator's front panel to set this program running. Click some of the switches in the upper bank and observe that – not surprisingly – the corresponding LEDs light up to reflect which switches are Up / Active / Logic 1 as illustrated below:

Click the Reset button to terminate the program. Your task is to modify this program to generate the even parity bit corresponding to the number of switches in their Up (logic 1) position and to display this bit on the single decoded 7-segment display as illustrated below:

Remember that your mission is to create two programs in the DIY Calculator's assembly language that perform this task:

a) Using the least number of instructions.

b) Using the smallest amount of memory. Some possible solutions are described on the following pages … can you come up with something better? If you do come up with an alternative technique (smaller, faster, better, novel, interesting, or outrageously silly) please send it to max@diycalculator.com and I'll add it in to this paper (crediting you, of course). Note: Don’t look at the following solutions until you've tried working this out for yourself, otherwise you'll spoil the fun!

Solution #1: Least Number of Instructions (6)

Solution #2: Smallest Amount of Memory (39 bytes)