Introduction to Programming Assignment: General Looping Exercises

Introduction

Your first assignment will consist of two small C programs that mostly involve basic iteration logic.

Please note that your programs should comply with the commenting and formatting rules as described in class and in the formatting file on eLearning. For example, there should be a header for the whole program that gives the author's name, class name, date, and description. End braces should be commented, and there are alignment and indenting requirements as discussed. A file on eLearning describes these requirements. Please ask if you have any questions.

Program #1: Creation of an ASCII Table

Write a C program that implements that ASCII table given on Slide 30 of the first slide set. That ASCII table will be reproduced below for reference.

Your program should first print out the column headings. It should then print out the binary, octal, decimal, hexadecimal and character versions of the ASCII characters from 32 to 126 (decimal), as indicated in the table. Two vertical columns should be sufficient.

Bin    Oct    Dec   Hex    Char        Bin    Oct   Dec   Hex    Char
                 32
                 33

Note that the columns should run top to bottom (instead of left to right). The range between 32 and 126 has an odd number of entries. Therefore, the left hand column will have one more entry in it than the right hand column.

As we will see shortly, the decimal, octal, and hexadecimal versions of these numbers can be easily displayed using the built-in conversion codes of printf(). The binary versions, however, are more difficult. Two algorithms for converting a decimal number to binary are (1) repeatedly divide the decimal number and its quotients by 2 and collect the remainders (the last remainder collected will be the most significant digit of the result), (2) create the hexadecimal equivalent of the original decimal number and use that hexadecimal intermediate to create the binary. The latter technique depends on the fact that the 16 hexadecimal digits (ranging from 0 to F) exactly correspond to the 16 numbers that can be created out of four bits (ranging from 0000 to 1111). The four bit binary patterns can be created from the hexadecimal digits and concatenated to produce the final result.

For this assignment, let's use the first algorithm: repeated divisions by 2. For an example, let's say our current decimal number is 74 (corresponding to a ‘J' in the ASCII table). If we use this method, we would have:

74 / 2 = 37 R 0
37 / 2 = 18 R 1
18 / 2 = 9 R 0
9 / 2 = 4 R 1
4 / 2 = 2 R 0
2 / 2 = 1 R 0
1 / 2 = 0 R 1

After each division we capture the remainder and then divide the quotient from the previous division by 2. The process stops when the quotient becomes 0 (which it always will). The remainders are then displayed in reverse order (i.e., the last remainder collected is the most significant digit of the result) to produce the final answer: 1001010. Note that these digits should be printed out as they are in the chart, with a space between the first and second nibbles. Furthermore, for the purposes of this assignment, let's also display the leading 0 bit (even though it is not shown in the table). The final result would then be displayed as:

0100 1010

The calculation of the binary should be placed in its own function, which ever method you use. Note that you should never return a pointer from a function to something that was declared locally within that function. Therefore, if you intend to return any kind of an array from a function, it must be passed into the function as an argument. (Alternatively, you could dynamically allocate the array. But we will discuss that issue later in the course.)

Program #2: Drawing Triangles

Write a program that asks the user to enter an integer between 1 and 15. If the number entered is outside that range, your program should print out an error message and re-prompt for another number. (This is an input validation loop.)

Once the user enters a number in the correct range, your program will print out four patterns of asterisks that look like the following. Note that the number provided by the user is equal to the height of the pattern.

Let's say the input value was 8. Then the output should be:

********
*******
******
*****
****
***
**
*

********
*******
******
*****
****
***
**
*
           *
          ***
        *****
      *******
     *********
    ***********
  *************
***************

For the final pattern, ask the user for an odd number between 1 and 15. (Your program should use an input validation loop to restrict valid input from the user to odd numbers between 1 and 15.) If that number is 7, then the diagram appears as follows:

Note that, in contrast to the previous diagrams, there are spaces between adjacent asterisks on the first and last lines.