Computation

Computations are typically done through functions. So far, we have only shown one function which is the main function int main(void). As a good practice (and is actually enforced in a strict ANSI C standard), a function body has two parts:

1. Declarations: This part contains all the variables to be used by the function. It tells the compiler what type of memory cells are needed.
2. Executables: This part contains the instructions on how to process the memory cells.

1
2
3
4
5

int main(void) {
  /* Declaration Statements */
  /* Executable  Statements */
  return 0;
}

Assignment Statements

The sequence of evaluation of an assignment is as follows:

1. Evaluate <lvalue> into an assignable location.
2. Evaluate <expr> into a value.
3. Assign the value from (2) into the location from (1).

This sequence of operations allows us to evaluate an assignment that does not make sense mathematically: sum = sum + item. Mathematically, there is no such number that is equal to itself plus another number unless the other number is 0. As an assignment, the evaluation can be summarised in the diagram below.

1
2
3

c = 3 + 6;
b = c;
a = b;

1
2

32 = a;    // '32' is not an assignable location (e.g., variable)
a + b = c; // 'a + b' is an expression, also not assignable

Arithmetic Operations

The arithmetic operations in C can be summarised as the table below:

When multiple operations are used in a single expression, the order of evaluation follows the operator precedence.

The operators with the lower precedence are evaluated first. Since there can be multiple operators with the same precedence, the associativity is used to resolve the order.

One way to easily evaluate any expression is to put parentheses around the operands based on the precedence above. For instance, given the expression 5 - 6 * 7 + 4 / 5, we repeatedly put parentheses using the precedence table from lowest precedence to largest precedence. If there are operators on the same precedence level, we resolve by associativity.

1
2
3
4
5

5 - 6 * 7 + 8 / 5
⇒ 5 - (6 * 7) + 8 / 5       // */ higher precedence over +-; left-associative
⇒ 5 - (6 * 7) + (8 / 5)     // /  higher precedence over +-
⇒ (5 - (6 * 7)) + (8 / 5)   // +- has the same precedence; left-associative
⇒ ((5 - (6 * 7)) + (8 / 5)) // +  is the only operation left

1
2
3
4
5

((5 - (6 * 7)) + (8 / 5))
⇒ ((5 - 42) + (8 / 5)) // innermost
⇒ (-37 + (8 / 5))      // left-most
⇒ (-37 + 1)            // innermost: integer division
⇒ -36                  // simple operation

To show the arithmetic operation in action, we will use the program ArithOps.c below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// To illustrate some arithmetic operations in C
#include <stdio.h>
int main(void) {
  int x, p, n; 

  // to show left associativity
  printf("46 / 15 / 2 = %d\n", 46/15/2);
  printf("19 %% 7 %% 3 = %d\n", 19%7%3);

  // to show right associativity
  x = -23;
  p = +4 * 10;
  printf("x = %d\n", x);
  printf("p = %d\n", p);

  // to show truncation of value
  n = 9 * 0.5;
  printf("n = %d\n", n);

  return 0;
}

Division and Remainder

When we perform operations with different numeric types (i.e., combinations of int and either float or double), the result follow the most general type. Since technically all whole numbers can be represented as real numbers by adding .0 at the end, float and double are considered more general than int.

In the case of division where both operands are int, we also expect the result to be int. This resulting int is obtained by simply truncating the values after the decimal point. Such division operation is called integer division. Not to be confused with Python's floor division.

Type casting may also affect the division operation. But since type cast operation has a very high precedence, we have to be careful with the order of operation.

1
2
3
4
5
6
7
8

int main(void) {
  int aa = 6; float ff = 15.8;
  float pp = (float) aa / 4;   // pp = 6.0 / 4 = 1.5
  int   nn = (int) ff / aa;    // nn = 15 / 6 = 2
  float qq = (float) (aa / 4); // qq = (float) (6/4) = (float) 1 = 1.0
  printf("%f %d %f\n", pp, nn, qq);
  return 0;
}

Selection

C provides two control structures that allow you to select a group of statements to be executed or skipped when certain conditions are met. The conditions are expressions that are evaluated to Boolean values (i.e., either true or false²). They are usually composed of expressions combined with relational operators and logical operators.

1
2
3

#define false 0
#define true  1
#define bool  char

As the Boolean macro expansion above shows, true is equal to 1 and false is equal to 0. However, any non-zero values are treated as true. But note, non-zero values except 1 is not equal to true. This will be made clear below.

Logical operators are used to combine two or more Boolean expressions. They can be used to form complex logical statements such as:

• If temperature is greater than 40C or blood pressure is greater than 200, then go to A&E immediately.
• If all the three subject scores (English, Maths and Science) are greater than 85 and mother tongue score is at least 80, recommend taking Higher Mother Tongue.

We usually summarise the logical operators using their truth table.

Short-Circuit

The main difference between short-circuit truth table and the basic truth table is whether the variable/expression represented by Y is going to be evaluated or not. In the case of &&, Y is only evaluated when X is true and in the case of ||, Y is evaluated only when X is false.

This allows for a "safe" execution especially in the case where the evaluation of Y may result in an error. Consider the case of finding an inverse of a number (i.e., 1/x). x cannot be 0 because we cannot divide by zero. We can safeguard this using short-circuit evaluation:

1
2
3

if((a != 0) && (b/a > 3)) {
  printf(...);
}

It is important to note that the result of relational and logical operators are always Boolean. In other words, it will always be either true or false.

Non-Zero

We mentioned that any non-zero values are treated as true but only 1 is equal to true. What do we mean by that? We will illustrate this with examples instead.

The first example below shows how we can evaluate a logical operation above using non-zero values.

1
2

printf("%d\n", 5 && 0); // 5 is true and 0 is false: true && false == false (0)
printf("%d\n", -1 || 0); // -1 is true and 0 is false: true || false == true  (1)

The second example below shows how these non-zero values --although treated as true-- are not equal to true unless the value is 1. While we did not mention false, it should be clear that is will be equal to 0.

1
2
3
4
5

printf("%d\n", 1 == true);   // true  (1)
printf("%d\n", -1 == true);  // false (0): although -1 is treated as true
printf("%d\n", 0 == true);   // false (0)
printf("%d\n", 0 == false);  // true  (1)
printf("%d\n", -1 || false); // true  (1)

1
2
3
4
5

int x, y, z
    a = 4, b = -2, c = 0;
x = (a > b || b > c && a == b);
y = ((a > b || b > c) && a == b);
z = ((a > b) && !(b > c));

Selection Statement

If-Statement

1
2
3

if(condition) {
  /* Execute these statements if TRUE  */
}

1
2
3
4
5

if(condition) {
  /* Execute these statements if TRUE  */
} else {
  /* Execute these statements if FALSE */
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

if(cond1) {
  /*
    Execute these statements if cond1 is TRUE
  */
  then_body;
} else if(cond2) {
  /*
    Execute these statements if cond1 is FALSE
    and cond2 is TRUE
  */
  elif_body;
} else {
  /*
    Execute these statements if cond1 is FALSE
    and cond2 is FALSE
  */
  else_body;
}

1
2
3
4
5
6

int number;
scanf("%d", &number);
if(number < 0) {
  number = number * -1;
}
printf("%d\n", number);

Switch-Case

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

switch(variable_or_expression) {
  case value1:
    /* Code to execute if variable_or_expression == value1 */
    value1_body;
    break; // Prevents spill over to next case
  case value2:
    /* Code to execute if variable_or_expression == value2 */
    value2_body;
    // no break can spill over to next case
  case value3:
    /* Code to execute if variable_or_expression == value3 */
    value3_body;
    break;
  default:
    /*
      Code to execute if variable_or_expression
      is not equal to any of the cases above
    */
    default_body;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

char character;
scanf("%c", &character);
switch(character) {
  case 'K':
    printf("King\n");
    break;
  case 'Q':
    printf("Queen\n");
    break;
  case 'R':
    printf("Rook\n");
    break;
  case 'B':
    printf("Bishop\n");
    break;
  case 'N':
    printf("Knight\n");
    break;
}

Repetition

Repetition Statement

C provides three control structures that allow you to select a group of statements to be executed repeatedly.

While-Loop

1
2
3

while(condition) {
  body;
}

1
2
3
4
5

int sum = 0, i = 1;
while(i <= 10) {
  sum = sum + i;
  i++;
}

Do-While-Loop

1
2
3

do {
  body;
} while(condition);

1
2
3
4
5

int sum = 0, i = 1;
do {
  sum = sum + i;
  i++;
} while(i <= 10);

For-Loop

1
2
3

for(init; condition; update) {
  body;
}

1
2
3
4

int sum, i;
for(sum = 0, i = 1; i  <= 10; i++) {
  sum = sum + i;
}

Break and Continue

There are two statements that can be used within a repetition structures:

1. break: This statement exits the nearest loop. In other words, it jumps out of the nearest loop³.
2. continue: This statement continues to the end of the loop body. In other words, it jumps to just after the last line of the body of the nearest loop but before going back to the top.

1
2
3

for(init; condition; update) {
  body;
}

1
2
3
4
5

init;
while(condition) {
  body;
  update;
}

1
2
3
4
5

printf("Without 'break':\n");
for(i=1; i<=5; i++) {
  printf("%d\n", i);
  printf("Ya\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Without 'break':
1
Ya
2
Ya
3
Ya
4
Ya
5
Ya

1
2
3
4
5
6
7

printf("With 'break':\n");
for(i=1; i<=5; i++) {
  printf("%d\n", i);
  if(i == 3)
    break;
  printf("Ya\n");
}

1
2
3
4
5
6
7

printf("With 'break':\n");
for(i=1; i<=5; i++) {
  printf("%d\n", i);
  if(i == 3)
    break; // ----------+
  printf("Ya\n");  //   |
} // <------------------+

1
2
3
4
5
6

With 'break':
1
Ya
2
Ya
3

1
2
3
4
5
6
7
8
9

printf("With 'break' in a nested loop:\n");
for(i=1; i<=3; i++) {
  for(j=1; j<=5; j++) {
    printf("%d, %d\n", i, j);
    if(j == 3)
      break;
    printf("Ya\n");
  }
}

1
2
3
4
5
6
7
8
9

printf("With 'break' in a nested loop:\n");
for(i=1; i<=3; i++) {
  for(j=1; j<=5; j++) {
    printf("%d, %d\n", i, j);
    if(j == 3)
      break; // ---------+
    printf("Ya\n"); //   |
  } // <-----------------+
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

With 'break' in a nested loop:
1, 1
Ya
1, 2
Ya
1, 3
2, 1
Ya
2, 2
Ya
2, 3
3, 1
Ya
3, 2
Ya
3, 3

1
2
3
4
5

printf("Without 'continue':\n");
for(i=1; i<=5; i++) {
  printf("%d\n", i);
  printf("Ya\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

Without 'continue':
1
Ya
2
Ya
3
Ya
4
Ya
5
Ya

1
2
3
4
5
6
7

printf("With 'continue':\n");
for(i=1; i<=5; i++) {
  printf("%d\n", i);
  if(i == 3)
    continue;
  printf("Ya\n");
}

1
2
3
4
5
6
7

printf("With 'continue':\n");
for(i=1; i<=5; i++) { // <--+
  printf("%d\n", i);  //    |
  if(i == 3)  //            |
    continue; // -----------+
  printf("Ya\n");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

With 'continue':
1
Ya
2
Ya
3
4
Ya
5
Ya

1
2
3
4
5
6
7
8
9

printf("With 'continue' in a nested loop:\n");
for(i=1; i<=3; i++) {
  for(j=1; j<=5; j++) {
    printf("%d, %d\n", i, j);
    if(j == 3)
      continue;
    printf("Ya\n");
  }
}

1
2
3
4
5
6
7
8
9

printf("With 'continue' in a nested loop:\n");
for(i=1; i<=3; i++) {
  for(j=1; j<=5; j++) { // <-------+
    printf("%d, %d\n", i, j); //   |
    if(j == 3)  //                 |
      continue; // ----------------+
    printf("Ya\n");
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

With 'continue' in a nested loop:
1, 1
Ya
1, 2
Ya
1, 3
1, 4
Ya
1, 5
Ya
2, 1
Ya
2, 2
Ya
2, 3
2, 4
Ya
2, 5
Ya
3, 1
Ya
3, 2
Ya
3, 3
3, 4
Ya
3, 5
Ya

Exercises

Arithmetic

1

0

1

32.00

1

100

1

212.00

1

32

1

89.60

1
2
3
4
5

int celcius;
double fahrenheit;
scanf("%d", &celcius);
fahrenheit = celcius * 9.0 / 5 + 32;
printf("%.2f\n", fahrenheit);

1

32

1

0.00

1

212

1

100.00

1

100

1

37.78

1
2
3
4
5

int fahrenheit;
double celcius;
scanf("%d", &fahrenheit);
celcius = (fahrenheit - 32) * 5.0 / 9;
printf("%.2f\n", celcius);

Selection Statement

1

2004

1

Leap Year

1

2100

1

Common Year

1

2000

1

Leap Year

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int year;
scanf("%d", &year);
if(year % 400 == 0) {
  printf("Leap Year\n");
} else if(year % 100 == 0) {
  printf("Common Year\n");
} else if(year % 4 == 0) {
  printf("Leap Year\n");
} else {
  printf("Common Year\n");
}

1

60 1.70

1

Normal

1

80 1.75

1

Overweight

1

80 1.60

1

Obese

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

double weight, height, bmi;
scanf("%lf %lf", &weight, &height);
bmi = weight / height / height;
if(bmi < 18.5) {
  printf("Underweight\n");
} else if(bmi < 25.0) {
  printf("Normal\n");
} else if(bmi < 30.0) {
  printf("Overweight\n");
} else {
  printf("Obese\n");
}

Repetition Statement

1

3

1

7

1

7

1

16

1

1

1

0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int n, step = 0;
scanf("%d", &n);
while(n > 1) {
  step++;
  if(n % 2 == 0) {
    n = n/2;
  } else {
    n = 3*n+1;
  }
}
printf("%d\n", step);

1
2
3
4
5
6

5
1.1
1.2
1.3
1.4
1.5

1

1.30

1
2
3
4
5
6
7
8

int n, i;
double total = 0, curr;
scanf("%d", &n);
for(i=0; i<n; i++) {
  scanf("%lf", &curr);
  total += curr;
}
printf("%.2f\n", total/n);

1
2
3
4
5
6

1.1
1.2
1.3
1.4
1.5
-0.1

1

1.30

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

int n = 0, i;
double total = 0, curr;
do {
  scanf("%lf", &curr);
  total += curr;
  n++;
} while(curr > 0);
total -= curr; // offset the last number
n--;           // offset the last count
printf("%.2f\n", total/n);

Break and Continue

1

9

1

composite

1

5

1

prime

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

int n, div;
bool is_prime = true; // a flag to indicate that the number is prime
scanf("%d", &n);
for(div=2; div*div <= n; div++) {
  // div*div <= n is the second improvement
  // but can simply do div < n
  if(n % div == 0) {
    is_prime = false;
    break;
  }
}
if(is_prime == true) {
  printf("prime\n");
} else {
  printf("composite\n");
}

Challenges

We will not give the answers for these challenges.

1
2
3
4
5
6

1
2
3
4
5
-1

1

0.50

1
2
3
4
5
6

1.1
1.2
1.3
1.4
1.5
-1.0

1

0.50

1
2
3
4
5
6

1.1
1.1
1.1
1.2
1.3
-1.0

1

0.30