BRZ | Open platform

I came up with this solution now its working

Since empty ('') is falsy value you can use false value check. You can also use trim if you think there can be space (' ')

The issues in your program can be categorised in:

1. Issues related to labels that a good simulator should detect before running your program
2. Issues related to program logic, that make the program produce the wrong output
3. Issues related to code style

A good simulator should not accept the following errors:

• PRINTF label is not defined.

  There is a brz printf instruction, but that label is not defined, since --- makes it a comment. Obviously that --- needs to be removed for the label reference to be valid.

• LDIT label is duplicate:

  The label LDIT is defined twice. This will have unreliable behaviour. A good simulator should give an error message about this, but other simulators will just take one definition and ignore the duplicates. Either way, the intention of the program is that one STA LDIT uses the first LDIT location and the second STA LDIT uses the second LDIT location. If anything, this will not be what happens. So rename one of the two labels, and adjust one of the STA LDIT instructions accordingly.

• zero label is undefined:

  The code to reset the counter refers to an undefined label zero. Again, good simulators will produce an error when loading the program, but others may silently use mailbox 0 instead, which leads to undesirable behaviour. So define the zero label as

The xx in your program show that you haven't taken the hint from How can I store an unknown number of inputs in different addresses in LMC (little-man-computer)?

It explains how you can have self-modifying code to walk through an array -- either to store values or to load them.

In your attempt there is no section that deals with outputting.

For the start section of the program I would actually suggest to subtract first the 100 and then 899 (which amounts to 999). That way you can keep the (reducing) input in the accumulator without having to restore it.

Also, due to an ambiguity in the specification of LMC, it is not entirely "safe" to do a BRZ right after a SUB (this is because the content of the accumulator is undefined/unspecified when there is underflow, so in theory it could be 0). You should always first do a BRP before doing a BRZ in the branched code. However, as input cannot be greater than 999, a BRP is enough to detect equality.

For the self modifying part, you can set an end-marker in your array data section, and define the LDA and STA instructions that would read/store a value at the end of the array. Whenever your code has that exact instruction, you know you have reached the end.

Here is how it can work:

Hopefully this will help you get started. This should give you the channel column you are looking for.

The code you have does not use the first input. Instead it uses FOUR. This is the first thing to change, as you don't want to loop exactly four times, but as many times as your first input is.

Secondly, you don't need to store each next input in a separate mailbox. Instead you can immediately process the 0/1 input as it decides whether you want to add something to the result or not. So you only need to update the result depending on the input's 0/1 value. You don't need to store that 0/1 value itself -- so no need of A, B, C...etc. Instead put the IN instruction inside the loop.

Then remains what exactly you should add to the result when an input turns out to be 1. As the input is in reversed order (the least significant bits come first), you should keep track of a power of 2, which you double in each iteration of the loop. That will be the number to add to the result whenever you encounter an input of 1. Because that is how the binary system works. For instance if the input of digits is 1 1 0 1, then the calculation is:

So here is the script for that. You can run it here: first run the code snippet (which starts the LMC simulator) and then use the controls in the right panel:

Just use the comments as inspiration for the labels. Lines that are not the target of any operation can go without labels. So for instance:

Currently you correctly get the input, calculate the remainder and output it. You just miss the part where you calculate the quotient and output it. The quotient is really the number of times you jump back to the start of the loop. So, increment a counter in each iteration of the loop. Then when you exit the loop you'll have counted one too many, so for the quotient you would output one less than that value.

Other remarks:

• It is not necessary to perform LDA RESULT if it immediately follows STA RESULT, since that value is still in the accumulator -- no need to reload it.

• There is no need to have HLT followed by HLT. That second one will never be executed.

• It is not useful to say in comments what an LMC instruction does... For instance, "ask the user" is not a useful comment next to INP. Comments should explain something more -- something that is specific to this program. Most of your comments are just saying what someone could look up in a LMC language specification. That is not the purpose of comments.

So here is your code with the extra counter for getting the quotient, and with the above remarks taken into account. You can run it here.

The self-modifying code pattern, that you have used to store the input, can also be used to output it. Instead of modifying the dynamic STO PRG instruction, you would have a dynamic LDA PRG instruction.

Your attempt shows no code for determining the minimum and maximum value. You can either collect this information during the input loop or during the output loop.

Please take into consideration these additional remarks:

• initialise the variables (that are not constants) with code, so that if the LMC is reset (without a complete re-assembly), it still works correctly.
• use more descriptive labels and variable names. ST and PRG are quite obscure names...

So it could work like below. This code uses the LMC mnemonics as described on Wikipedia. So STA = STO and INP = IN. You can run the program here: