10.2: Create the Algorithm

The algorithm is the name for the unambiguous, ordered sequence of steps involved in solving the problem. Once the program is understood, a series of steps can be developed to solve that problem. There can be, and usually are, multiple correct solutions to a given problem.

The process for creating an algorithm can be different for different people. In general, some time should be devoted to thinking about possible solutions. This may involve working on some possible solutions using a scratch piece of paper. Once an approach is selected, that solution can be developed into an algorithm. The algorithm should be written down, reviewed, and refined. The algorithm is then used as the outline of the program.

For example, we will consider the integer to ASCII conversion problem outlined in the previous section. To convert a single digit integer (0-9) into a character, \(48_{10}\) (or “0” or 0x30) can be added to the integer. For example, 0x01 + 0x30 is 0x31 which is the ASCII value of “1”. It should be obvious that this trick will only work for single digit numbers (0-9).

In order to convert a larger integer (10) into a string, the integer must be broken into its component digits. For example, \(123_{10}\) (0x7B) would be 1, 2, and 3. This can be accomplished by repeatedly performing integer division by 10 until a 0 result is obtained.

For example;

\[\dfrac{123}{10} = 12 \ \ \ reminder3\nonumber\]

\[\dfrac{12}{10} = 11 \ \ \ \ reminder2\nonumber\]

\[\dfrac{1}{10} = 0 \ \ \ \ reminder1\nonumber\]

As can be seen, the remainder represents the individual digits. However, they are obtained in reverse order. To address this, the program can push the remainder and, when done dividing, pop the remainders and convert to ASCII and store in a string (which is an array of bytes).

This process forms the basis for the algorithm. It should be noted, that there are many ways to develop this algorithm. One such approach is shown as follows:

    ;  Part A - Successive division
    ;       digitCount = 0
    ;       get integer
    ;  divideLoop:    
    ;       divide number by 10
    ;       push remainder
    ;       increment digitCount
    ;       if (result > 0) goto divideLoop
    
    ;  Part B – Convert remainders and store
    ;        get starting address of string (array of bytes)
    ;        idx = 0
    ;        popLoop:
    ;        pop intDigit
    ;        charDigit = intDigit + “0” (0x030)
    ;        string[idx] = charDigit
    ;        increment idx
    ;        decrement digitCount
    ;        if (digitCount > 0) goto popLoop
    ;        string[idx] = NULL

The algorithm steps are shown as program comments for convenience. The algorithm is typically started on paper and then more formally written in pseudo-code as shown above. In the unlikely event the program does not work the first time, the comments are the primary debugging checklist.

Some programmers skip the comments and will end up spending much more time debugging. The commenting represents the algorithm and the code is the implementation of that algorithm.