Decimal To Binary:

• Step 1: Divide the number by 2 and note down the remainder (Ex. 52 / 2 = 26 with remainder 0, 23 / 2 = 11 with remainder 1)
• Step 2: Repeat Step 1 by dividing the result by 2 (noting down the remainder again) until you get 0 as the quotient
• Step 3: Now you should have a list of 1's and 0's noted down. To write the number in binary, reverse this list from the last remainder you got to the first remainder (reverse order)

Binary To Decimal:

• Step 1: Multiply every digit (starting from the right) by the powers of 2, starting with 2⁰. Then, increase the exponent by 1 each time you move digits.
• Step 2: Now, sum up all of these values that you obtained for each digit. This will give you the decimal representation of the binary number.

Decimal To Hexadecimal:

• Step 1: Similar to decimal to binary, divide the number by 16 and note down the remainder (using A for 10, B for 11, C for 12, D for 13, E for 14, F for 15).
• Step 2: Repeat step 1 by dividing the result by 16 (noting down the remainder again) until you get 0 as the quotient
• Step 3: To write the number in hexadecimal, reverse this list from the last remainder you got to the first remainder (reverse order)

Hexadecimal To Decimal:

• Step 1: Multiply every digit (starting from the right) by the powers of 16, starting with 16⁰. Then, increase the exponent by 1 each time you move digits.
• Step 2: Now, sum up all of these values that you obtained for each digit. This will give you the decimal representation of the hexadecimal number.

Before looking at actual programming topics, you should understand basic C syntax and good coding practices:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>
#include <stdlib.h>

/* constants */
#define CONSTANTNAME 100

int main(void) {

  // your code

  system("PAUSE");
  return 0;
}

How To Declare A Variable: Declaring a variable is always the same syntax: first is the variable type (int, double, etc.), followed by the variable name. You can optionally set this variable to some value using an equals sign followed by the value you want to set it to. Note that in both cases, the statement should end with a semi-colon.

int main(void) {

  int variableName;
  double x = 10.1;

  // ...more code

  system("PAUSE");
  return 0;
}

You can set these variables to some value later on in your code. Also note that it is good practice to give your variables good names so that other people are able to understand your code (I did not do this).

int main(void) {

  int variableName;
  double x = 10.1;

  // ...more code

  x = 220.112
  variableName = 123

  // ...more code

  system("PAUSE");
  return 0;
}

Casting: One question you may have is what if you try to add two different types together or if you divide two ints, what will the result be? This is why we need casting. Casting refers to the process of converting one data type to another or a more formal definition: it allows you to explicitly change the interpretation of a value to a different data type. Casting is useful when you want to perform operations that involve different data types.

For example, if you have two variables of type int, and you want to divide them and store the result in a variable of type double, you would need to cast one of the variables to double before performing the division. This ensures that the division operation is carried out with double precision and that the result is stored as a double.

int main(void) {

  int x = 12;
  int y = 5;
  int result = (double)x / y;  // Casting x to double

  // result = 2.4

  system("PAUSE");
  return 0;
}

Control structures are used to control the flow of execution within a program. They determine which statements are executed and when, based on certain conditions or criteria. However, before we look at these we should first understand the relational operators (logical expressions):

Now that we have looked at logical expressions, we can look at the different control structures:

if (condition) {
  // code run if condition true
}

else {
  // code run if condition false
}

if (condition1) {
  // code run if condition1 true
}

else if (condition2) {
  // code run if condition2 true, condition1 false
}

else {
  // code run if condition1 and condition2 are false
}

int x = 10;

if (x < 10) {
  printf("x is small.\n");
}

else if (x == 10) {
  printf("x is equal to 10.\n");
}

else {
  printf("x is big.\n");
}

x is equal to 10.

while (condition) {
  // code run as long as condition true
}

int x = 10;

while (x >= 0) {
  printf("%d ", x);
  x = x - 1;
}

10 9 8 7 6 5 4 3 2 1 0 

do  {
  // code to be executed
} while (condition);

int x = 0;

do  {
  printf("%d ", x);
  x++;
} while (x < 10);

0 1 2 3 4 5 6 7 8 9 

File input/output allows you to read data from and write data to files on your computer's storage. Typically, you can follow a sort of template when dealing with files:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

#define INPUTFILE "fileName.txt"

int main(void) {

  FILE *file;

  file = fopen(INPUTFILE, "r");

  if(file == NULL) {
    printf("Error opening the file!\n");
  }

  else {
    // access file
    fclose(file);
  }

  system("PAUSE");
  return 0;
}

A function is a block of code that performs a specific task. It's a way to organize and reuse code, making your programs more modular and easier to understand. Functions always follow this template:

returnType functionName(parameter1, parameter2, ...) {
  // Function body (code)
  // Perform tasks here
  // Optionally, return a value using the return statement
}

• returnType: This specifies the type of value that the function returns, such as int, double, void (no return value), etc.
• functionName: This is the name you give to your function.
• parameter1, parameter2: These are variables that you can pass to the function, which it can use to perform its tasks. Parameters are optional, and you can have none or multiple parameters. Each parameter has a type and a name.
• Function Body: This is where you write the actual code for the function. It consists of a series of statements enclosed within curly braces . The statements define what the function does when it is called.
• Return Statement: If the function has a return type other than void, you can use the return statement to send a value back to the code that called the function. The return statement also exits the function, so any code after it won't be executed.

We will go over a few examples to help you understand functions.

Example #1: Say in your code you have to print out multiple addition calculations. We could write code that looks like this that would work, but could become very confusing to someone else reading our code and could lose its neatness:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

int main(void) {

  int val1 = 10
  int val2 = 213
  int sum;

  sum = val1 + val2;

  printf("The sum of %d and %d is %d.\n", val1, val2, sum);

  val1 = 15;
  val2 = 17;

  sum = val1 + val2;

  printf("The sum of %d and %d is %d.\n", val1, val2, sum);

  val1 = 1;
  val2 = 2;

  sum = val1 + val2;

  printf("The sum of %d and %d is %d.\n", val1, val2, sum);

  val1 = 14;
  val2 = 18;

  sum = val1 + val2;

  printf("The sum of %d and %d is %d.\n", val1, val2, sum);

  system("PAUSE");
  return 0;
}

The sum of 10 and 213 is 223.
The sum of 15 and 17 is 32.
The sum of 1 and 2 is 3.
The sum of 14 and 18 is 32.

We only made four calculations and the code is already getting confusing to look at. We can replace this repeated code with a function to reduce repetition:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

void add(int number1, int number2) {
  int sum = number1 + number2;
  printf("The sum of %d and %d is %d.\n", number1, number2, sum);
}

int main(void) {
  add(10, 213);

  add(15, 17);

  add(1, 2);

  add(14, 18);

  system("PAUSE");
  return 0;
}

The sum of 10 and 213 is 223.
The sum of 15 and 17 is 32.
The sum of 1 and 2 is 3.
The sum of 14 and 18 is 32.

The for loop is a type of loop (similar to a while loop) that allows you to repeatedly execute a block of code for a specific number of times. It consists of three parts: initialization, condition, and iteration. If you are able to understand for loops, it will make learning arrays much easier. This is the general syntax of a for loop (notice the semicolon syntax):

for (initialization; condition; iteration) {
  // code executed each iteration
}

The initialization is usually used to set the loop counter, the condition specifies the condition for continuing the loop, and the iteration defines how the loop counter is updated after each iteration. The code inside the for block will be executed repeatedly until the condition becomes false.

Example #1:

int iterator = 0;

for (iterator; iterator < 5; iterator++) {
  printf("%d ", iterator);
}

0 1 2 3 4

Example #2:

for (int i = 0; i <= 10; i+=2) {
  printf("%d ", i);
}

0 2 4 6 8 10

In this example, we declared the iteration variable inside the loop. This is very common as this limits the "scope" of this variable to the for loop only, meaning that you cannot use this variable outside of your for loop (which is good as it reduces errors). We also incremented this value by two each iteration instead of one. You can start to do more interesting things with for loops, such as creating designs/symmetry. However, to do this we need to introduce nested for loops, which is a for loop "inside" another for loop. Look at the example below:

Example #3:

for (int i = 0; i < 5; i++) {
  for (int j = 0; j < 5; j++) {
    printf("* ");
  }
  printf("\n");
}

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

This is a bit more complex than the first two examples, so I will try my best to explain what is happening:

• The outer loop initializes a variable "i" to 0 and continues as long as "i" is less than 5. It controls the number of rows in the pattern.
• Inside the outer loop, we have a second inner loop that initializes a variable "j" to 0 and continues as long as "j" is less than 5. It controls the number of asterisks in each row.
• For each iteration of the inner loop, a single asterisk followed by a space is printed using the "printf("* ")" statement.
• After the inner loop completes all 5 iterations, a newline character ("\n") is printed using "printf("\n")"". This moves the cursor to the next line, starting a new row in the pattern.
• The outer loop then increments "i" by 1 and repeats the process until "i" is no longer less than 5.
• This entire process results in the printing of a square pattern with 5 rows and 5 columns.

You can start to create cool designs such as triangles, or diamonds too:

Example #4:

for (int i = 5; i > 0; i--) {
  for (int j = i; j > 0; j--) {
    printf("* ");
  }
  printf("\n");
}

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

This example is similar to Example #3, but it prints out a triangle. Here is a description of what is happening:

• The outer loop initializes a variable "i" to 5 and continues as long as "i" is greater than 0. It controls the number of rows in the pattern and decrements "i" by 1 on each iteration.
• Inside the outer loop, we have a second inner loop that initializes a variable "j" to the value of "i" and continues as long as "j" is greater than 0. It controls the number of asterisks to be printed in each row and decrements "j" by 1 on each iteration.
• For each iteration of the inner loop, an asterisk "*" followed by a space is printed using the printf("* ") statement.
• After the inner loop completes all its iterations, a newline character (\n) is printed using printf("\n"). This starts a new line, creating a new row in the pattern.
• The outer loop then decrements "i" by 1 and repeats the process until "i" is no longer greater than 0.
• This entire process results in the printing of a descending pattern of asterisks, with the number of asterisks in each row decreasing from 5 to 1.

Arrays are collections of elements of the same data type. It provides a way to store multiple values under a single name. Arrays are commonly used for tasks that involve working with multiple related data items, such as a list of numbers or a collection of doubles. For example, say we want to store the integer values of 10 different types of apples. We can create an array of integers type that can store 10 values:

int apples[10];

What we have done here is created an array of type "int" of size 10, however we have not actually stored any values in it. There are various ways to write data to arrays, but this is the simplest way:

int apples[10] = {1, 3, 2, 6, 2, 1, 9, 100, 20, 2};

We have now assigned a value to every "index" in the array. Now, say that we want to access the second value in our array. In C, array indexing starts from 0. To access an element, you use the array name followed by the index enclosed in square brackets:

int applePrice = apples[1];

What we have done here is retrieved the value at index 1 in our array and assigned it to a variable called "applePrice". If we do not need to assign the value to a variable, we can also print out the value:

printf("The price of the second apple is $%d.", apples[1]);

The price of the second apple is $3.

Printing out one value in an array isn't usually too helpful. Typically, you will use for loops to iterate through an array (maybe to find the maximum or minimum apple price, or calculate the sum of prices):

Example #1: Calculate the sum of all apple prices:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

#define SIZE 10

int main(void) {

  int apples[SIZE] = {1, 3, 2, 6, 2, 1, 9, 100, 20, 2};
  int sum = 0;

  for(int i = 0; i < SIZE; i++){
    sum += apples[i];
  }

  printf("The sum of the array is %d.\n", sum);

  system("PAUSE");
  return 0;
}

The sum of the array is 146.

What we did here was iterate through all 10 elements in the array (apples[0], apples[1], apples[2],...) and each iteration we added to the sum. I declared a constant called "SIZE" rather than directly using "10" as during the course, typically for the problems, you will be given a parameter called size (you will not know the value). This will make more sense as we look at more examples:

Example #2: Write a function that takes an array (of type int) and the size of the array and returns the maximum integer value:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

int maximum(int arr[], int size) {

  int maxVal = -1;

  for(int i = 0; i < size; i++){
    if(arr[i] > maxVal){
      maxVal = arr[i];
    }
  }

  return maxVal;
}

int main(void) {
  int values[10] = {20022, 1, 100, 10992, 2000, 11112, 91211, 10021, 2022, 1000};

  int maxNum = maximum(values, 10);

  printf("The maximum value is %d.", maxNum);

  system("PAUSE");
  return 0;
}

The maximum value is 91211.

What we did in this example was created a "temporary" variable to hold the maximum value. We set this variable to -1 but we could have also set it to the value at index 0. At each iteration in the for loop, we checked if the value at that index was greater than our maximum value at that time. If it was, then we updated our maximum value variable to the value at that index. We do this until we reach the end of the for loop, and at the end, the variable "maxVal" will contain the maximum value in the array. Note that the "Test" is just to show you how the code works but you will usually just be required to create the function. Whenever dealing with arrays, you will typically have to use some sort of iterative loop (while or for), so if you are not comfortable with using these, you should revise for loops before continuing. We will now look at 2-D arrays which are a similar to what we have looked at so far.

You can think of a 2-D array, also known as a two-dimensional array, as a table with rows and columns. It's used to store data in a grid-like structure where each cell can be accessed using two indices: one for the row and one for the column. We can initialize a 2-D array like this:

int example[4][3];

The "[4]" is the number of rows in our array and "[3]" is the number of columns in our array. If we want to initialize the values inside of this 2-D array, we can do the following:

int example[3][4] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}};

Similar to 1-D arrays, if we want to access a certain value in our array, you use the array name followed by the index (both row and column) enclosed in square brackets:

int value = example[1][1];
printf("%d", value);

5

Typically, accessing one value in a 2-D array isn't too important. Often when working with 2-D arrays, we utilize nested for loops, so I would recommend reviewing nested for loops before continuing.

Example #1: Determine the largest integer value in the given 2-D array:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

#define ROW 3
#define COL 3

int main(void) {

  int exampleArray[ROW][COL] = {{100, 212, 31}, {14, 500, 679}, {71, 81, 19}};
  int max = -1;

  for(int i = 0; i < ROW; i++){
    for(int j = 0; j < COL; j++){
      if(exampleArray[i][j] > max){
        max = exampleArray[i][j];
      }
    }
  }

  printf("The maximum number in the 2-D array is %d.\n", max);

  system("PAUSE");
  return 0;
}

The maximum number in the 2-D array is 679.

What we are doing in this example is utilizing a nested for loop in order to successfully iterate through all of the elements in the 2-D array. Our first for loop begins at row 0, then we enter the inner for loop where we start at column 0. We check if the element in row 0, column 0 is greater than the previous max value (-1), and update the max value to 100. Our inner for loop then increments and we repeat the same steps with the element at row 0, column 1. We repeat this until we reach the final column, then come back to the outer for loop. We keep repeating these steps until we reach the final row. After these for loops complete, we have successfully iterated through all of the elements. We then print out the max value. You can think of a 2-D array like a matrix or a chess board (as shown below). We start at 100, move to 212, then move to 31. We then move down a row and move left to right again, then repeat this until all of the elements have been reached.

As you can see, nested for loops are important when working with 2-D arrays. If you are comfortable with nested for loops, 2-D arrays should not be too difficult, so we will look at another example to become more familiar with them:

Example #2: Write a function that takes a 2-D array (of type int), the number of rows, number of columns, and a threshold value as parameters and returns the number of values greater than (or equal to) the threshold value:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

int thresholdNum(int arr[][ARRAY_COLS], int rows, int cols, int threshold) {

  int count = 0;

  for(int i = 0; i < rows; i++){
    for(int j = 0; j < cols; j++){
      if(arr[i][j] >= threshold){
        count++;
      }
    }
  }

  return count;
}

#define ARRAY_ROWS 4
#define ARRAY_COLS 3

int main(void) {
  int exampleArray2[ARRAY_ROWS][ARRAY_COLS] = {{12, 10, 1},{14, 5, 67}, {149, 2, 99}, {7, 8, 17}};

  int thresholdValue = 25;

  int numOverThreshold = thresholdNum(exampleArray2, ARRAY_ROWS, ARRAY_COLS, thresholdValue);

  printf("The number of values over the threshold value is %d.", numOverThreshold);

  system("PAUSE");
  return 0;
}

The number of values over the threshold value is 3.

As you can see, most 2-D array questions involve some sort of nested for loop, so most of the time when you see a 2-D array, implement some sort of nested loop (could also use while loops but I prefer for loops).

For the Arduino unit, you will do all of your work with a virtual Arduino board on Tinkercad. The questions always involve a "setup" and "loop" function. The setup funciton is to declare certain pins on the Arduino board as inputs or outputs, such as buttons and LEDs. The loop function continuously loops while the program is running. The most common example is programming an LED light to turn on and off. The code would look something like this:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 


void setup() {
  pinMode(13, OUTPUT);
  // Can declare more inputs and outputs here.
}

void loop() {
  digitalWrite(13, HIGH);
  delay(100);
  digitalWrite(13, LOW);
  delay(100);
}

In this example, we declared pin 13 on the Arduino board as an output (this is where the LED is connected). In the loop, we set pin 13 to "HIGH", signaling to turn the LED on. We then delayed for 100 milliseconds so we can see the LED actually blinking, then turned the LED off and delayed again. Since this code is in the loop function, this code continues to run until the program is stopped, so the light keeps blinking on and off.

The other type of question that you will have is dealing with inputs, such as buttons or switches. We will look at another problem which uses a switch to turn an LED light on and off:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 


int switchState;

void setup() {
  pinMode(0, INPUT);
  pinMode(1, OUTPUT);
}

void loop() {
  switchState = digitalRead(0);

  if(switchState == HIGH) {
    digitalWrite(1, HIGH);
  }

  else {
    digitalWrite(1, LOW);
  }
}

We first declared a variable called switchState of type int which we will use in the loop funciton. Under this in the setup function, we declared pin 0 as an input, and pin 1 as an output, meaning that our switch is connected to pin 0 and our LED is connected to pin 1. In the loop function, we use our switchState variable to hold the status of our switch (either HIGH = 1 or LOW = 0). We then turn the LED on if switchState is HIGH (the switch is on) or turn the LED off if switchState is LOW (the switch if off). Again, since this is in the loop function, the program continuously runs this code until the program is turned off.

The final unit that you will look at is strings. Strings in C are much different than other languages you may be familiar with such as Java or Python. Strings in C are actually 1-D arrays of type char terminated by a null character ('\0'). There are two ways you would initialize a string:

char hello1[] = {'h', 'e', 'l', 'l', 'o', '\0'};
// or
char hello2[] = "hello";

The types of questions you will see are usually require iterating through the character array, so a for loop would be the most helpful for string questions:

Example #1: Write a function that returns the number of 'a' characters in a given string:

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */

int countA(char str[]) {
  int count = 0;

  for(int i = 0; str[i] != '\0'; i++) {
    if(str[i] == 'a'){
      count++;
    }
  }

  return count;
}

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

int main(void) {
  char arr[] = "aabbaaa";
  int numberOfA = countA(arr);
  printf("The number of a's in the string %s is %d.", arr, numberOfA);

  system("PAUSE");
  return 0;
}

The number of a's in the string aabbaaa is 5.

In this example, we used a for loop to iterate through the inputted string until we reached the '\0' character at the end of the string. We checked if the character at each index was equal to 'a' and incremented the count variable if it was. We can think of the string like this:

So we start at the first character (a) and check if it is equal to 'a' (which it is so we increment count by 1). We then move to the second and continue iterating through the array. When we reach the '\0' character, we exit the for loop and return the value stored in count.

We are also able to modify a string and will look at this in the next example:

Example #2: Given an input string (of maximum 32 characters), switch all of the 'a' characters to 'c' and all of the 'b' characters to 'd'.

 /* 
 * Author: 
 * Student Number: 
 * Lab Section: 
 * Date: 
 * Purpose: 
 */ 

#include <stdio.h>

int main(void) {
  char arr[32];
  printf("Enter a string: ");
  fgets(arr, 32, stdin);

  for(int i = 0; arr[i] != '\0'; i++){
    if(arr[i] == 'a'){
      arr[i] = 'c';
    }
    else if(arr[i] == 'b'){
      arr[i] = 'd';
    }
  }

  printf("The new string is %s.", arr);

  system("PAUSE");
  return 0;
}

Enter a string: aaabbb
The new string is cccddd.

Instead of using scanf() as we have previously seen, in this example I used fgets(). When working with strings, you may run into problems using scanf() such as working with problems with empty inputs and reading '\n'. fgets() takes three parameters in: the first is where the result should be stored, the second is the maximum number of characters to be read (including the final null-character), and the final parameter is where the string is read from. In APSC160 this will always be stdin which stands for standard input - this is where you type the input for the program to read.

The problems you will see will require you to iterate through a string to either read or modify characters from it, so practice with the questions below to become more comfortable with strings.