CMP1025 Complete Study Guide

Functions — Complete Reference

Prototype → Call → Definition

Every function in C has exactly these three parts. You must know where each goes and what it looks like.

/* 1. PROTOTYPE — goes BEFORE main(), ends with ; */
int ADD(int, int);

int main() {
    /* 2. FUNCTION CALL — goes inside main */
    int result = ADD(10, 20);
    printf("%d", result);
    return 0;
}

/* 3. DEFINITION — goes AFTER main, no semicolon */
int ADD(int num1, int num2) {
    return num1 + num2;
}

All Function Variations

Type 1 — No return, No parameters (void/void)

void PrintMsg();          // prototype
PrintMsg();               // call
void PrintMsg() {         // definition
    printf("Hello UTech\n");
}

Type 2 — No return, Has parameters (void/params)

void PrintSum(int, int);   // prototype
PrintSum(10, 20);          // call
void PrintSum(int a, int b) {
    printf("%d\n", a + b);
}

Type 3 — Has return, No parameters (int/void)

int GetValue();
int x = GetValue();
int GetValue() {
    return 42;
}

Type 4 — Has return, Has parameters (the most common)

int ADD(int, int);
int result = ADD(10, 20);
int ADD(int num1, int num2) {
    return num1 + num2;
}

The Test's Q3/Q4/Q5 Template

This exact structure appears in EVERY practice test. Memorize it:

/* Q3: Prototype */
void FunctionName(int[], int);

/* Q4: Full Definition */
void FunctionName(int ARR[], int SIZE) {
    for (int i = 0; i < SIZE; i++) {
        printf("Enter value %d: ", i + 1);
        scanf("%d", &ARR[i]);
    }
}

/* Q5: Call in main */
FunctionName(ARR, 10);

Scope — Local vs Global

int globalVar = 100;    // global — any function can use

void myFunc() {
    int localVar = 5;   // local — only visible here
    {
        int blockVar = 3; // block scope — only in these braces
    }
    // blockVar is GONE here
}

Recursion

A function that calls itself. Every recursive function needs a base case (stops it) and a recursive case (calls itself with smaller input).

// Count down to 1
int fun(int n) {
    if (n == 1) return 1;         // BASE CASE
    else return 1 + fun(n - 1);    // RECURSIVE CASE
}
// fun(3) → 1 + fun(2) → 1 + 1 + fun(1) → 1+1+1 = 3

Arrays — 1D and 2D

Declaration, Initialization, Access

// Declare with size, uninitialized (GARBAGE values — danger!)
int scores[10];

// Declare + initialize ALL to zero (exam answer for Q1)
int scores[10] = {0};

// Declare with explicit values
int scores[5] = {25, 16, 89, 62, 12};

// Size inferred from initializer
int numbers[] = {1, 2, 3, 4, 5};  // size = 5

// Access: ALWAYS 0-indexed
scores[0]   // 1st element
scores[6]   // 7th element  ← EXAM TRAP
scores[9]   // 10th (last) element of size-10 array

Loop Through Array

for (int i = 0; i < SIZE; i++) {
    scanf("%d", &arr[i]);   // fill from user
    printf("%d ", arr[i]);  // print
}

Random Numbers

// Generate number from LOW to HIGH inclusive:
variable = rand() % (high - low + 1) + low;

// Required headers:
#include <stdlib.h>
#include <time.h>

// Seed (put in main once, before any rand() call):
srand(time(NULL));

Both test examples worked out

// -12 to 35: range = 35-(-12)+1 = 48, shift = -12
VALUES[6] = rand() % 48 + (-12);

// -30 to 15: range = 15-(-30)+1 = 46, shift = -30
BUFFER[1] = rand() % 46 + (-30);

Worksheet 4 examples

// 2 to 12: range=11, shift=2
printf("%d", 2 + rand() % 11);

// -5 to 5: range=11, shift=-5
printf("%d", -5 + rand() % 11);

// 10 to 25 (Worksheet 5 lab): range=16, shift=10
arr[i] = rand() % 16 + 10;

Array Calculations

2D Arrays

// Declaration: [rows][columns]
int grid[3][4];

// Initialize with braces-per-row
int b[2][2] = {{1,2}, {3,4}};

// Access: [row][col]
grid[1][2] = 25;   // row 1, column 2

// Nested loop to traverse
for (int row = 0; row < 3; row++) {
    for (int col = 0; col < 4; col++) {
        total += grid[row][col];
    }
}

// Pass 2D to function: MUST specify column size
void printMatrix(int matrix[][3], int rows);
//                           ↑ column size is mandatory!

Sorting Algorithms

The test asks you to do a manual trace — no code needed for Q6. You must show the array state after EVERY pass.

How Bubble Sort Works

Compare each adjacent pair from left to right. Swap if left > right. After each full sweep, the largest unsorted element has "bubbled" to the end. Repeat, but each pass covers one fewer element.

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
    }
}

Test 1 trace: 14, 3, 22, 11, 6, 19, 2, 9, -4, 7

How Insertion Sort Works

Pick element at position i. Slide it left, shifting larger elements right, until it lands in the correct spot in the already-sorted left portion. Like sorting cards in your hand.

void insertionSort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j+1] = arr[j];
            j--;
        }
        arr[j+1] = key;
    }
}

Test 2 trace: 18, 5, 12, 1, 20, 7, 4, 16, -2, 9

How Selection Sort Works

Find the minimum element in the unsorted portion, swap it to the front of the unsorted section. Repeat.

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        int minIdx = i;
        for (int j = i+1; j < n; j++) {
            if (arr[j] < arr[minIdx]) minIdx = j;
        }
        if (minIdx != i) {
            int temp = arr[i]; arr[i] = arr[minIdx]; arr[minIdx] = temp;
        }
    }
}

WS6 Q2 trace: 9, 20, 7, 18, 8, 41, 35, 6, 3, 13

Searching Algorithms

Check Every Element One By One

Works on any array (sorted or unsorted). Go through each element until you find the target. Return its index, or -1 if not found.

int linearSearch(int arr[], int size, int key) {
    for (int i = 0; i < size; i++) {
        if (arr[i] == key) {
            return i;   // found! return index
        }
    }
    return -1;           // not found
}

Eliminate Half the Array Each Step

Array must be sorted first. Check the middle element. If target is smaller, search left half. If larger, search right half.

int binarySearch(int arr[], int size, int key) {
    int start = 0, end = size - 1;
    while (start <= end) {
        int mid = (start + end) / 2;
        if (arr[mid] == key) return mid;
        else if (key < arr[mid]) end = mid - 1;
        else start = mid + 1;
    }
    return -1;
}

Pointers — Master The 10-Mark Question

What A Pointer Actually Is

A pointer is a variable that stores a memory address, not a regular value. It "points to" where another variable lives in memory.

int x = 5;            // normal variable, value=5, lives at some address
int *ptr = NULL;     // pointer to int, currently points nowhere

ptr = &x;            // &x = "address of x" → ptr now holds x's address
printf("%d", *ptr); // *ptr = "value at ptr's address" = 5
*ptr = 10;           // changes x to 10 via the pointer
ptr = NULL;          // ptr points nowhere again. x is still 10.

How To Solve Pointer Tables in 3 Steps

Step 1 — Write out the address table first

Before doing anything, write: "u is at 52012, v is at 52016, w is at 52020". This is your reference map.

Step 2 — Execute statements one at a time, left to right

For EACH statement: (a) identify what the pointer currently points to, (b) compute the new value, (c) update your table immediately before moving to the next statement.

Step 3 — Pointer cell shows an ADDRESS, not a value

When ptrA = &u, the value in the ptrA cell is 52012 (the address), not 6 (the value of u). Many students write 6 — that's wrong.

u=6, v=4, w=3, ptrA=NULL, ptrB=NULL

Addresses: u=52012, v=52016, w=52020

Explanation of each row

Row 1: ptrA = &u → stores u's address (52012). ptrB = &w → stores w's address (52020).

Row 2: *ptrA = u = 6. v = 6 + 4 = 10. *ptrB = w = 3. w = 3 + 2 = 5.

Row 3: *ptrB = w = 5. u = 5 − 1 = 4. v++ → v = 10 + 1 = 11.

Row 4: ptrA = &v → 52016. ptrB = ptrA → also 52016. Both point to v now.

Row 5: *ptrB = v = 11. v = 11 × 2 = 22. ptrA = NULL (v stays 22).

x=2, y=5, z=4, *left=NULL, *right=NULL

Addresses: x=63012, y=63016, z=63020

Explanation of each row

Row 1: left = &y → 63016. right = &z → 63020.

Row 2: *left = y = 5. x = 5 + z = 5 + 4 = 9. *right = z = 4. z = 4 − 1 = 3.

Row 3: *left = y = 5. y = 5 × 2 = 10. z++ → z = 3 + 1 = 4.

Row 4: left = &x → 63012. right = left → 63012. Both point to x.

Row 5: *right = x = 9. y = 10. x = 9 + 10 = 19. left = NULL.

Pointer ↔ Array Notation (WS8 Q2 & Q3)

// Array notation ↔ pointer notation are equivalent
arr[i]     == *(arr + i)    // accessing element
&arr[i]    == arr + i       // getting address

// WS8 Q2: Replace * with []
*(tax + 4)    == tax[4]
*(score + 2) == score[2]
*(number+10) == number[10]
*prices      == prices[0]    // no offset = index 0

// WS8 Q3: Replace [] with *
tax[6]   == *(tax + 6)
score[7] == *(score + 7)
num[4]   == *(num + 4)
prices[9]== *(prices + 9)

WS8 Q1 — Pointer to pointer

int x;
int* p = &x;
int ***pp = &p;   // pointer to pointer to pointer

// To access x's value:  **pp  (answer: e)
// *pp gives p (the address of x)
// **pp dereferences twice = x's value

Both Tests — Complete Answers

Click any question to reveal the answer and explanation.

Key Worksheet Answers

The tutorial questions that are most likely to appear in modified form on your actual test.

Q1: Write Prototypes for Each

// a. StartProgram — no args, no return
void StartProgram(void);

// b. InputValue — no args, returns float
float InputValue(void);

// c. OutputValue — int arg, no return
void OutputValue(int);

// d. CalculateTotal — three ints, returns float
float CalculateTotal(int, int, int);

// e. DetermineStatus — float arg, returns char
char DetermineStatus(float);

Q2: Function Calls for Each

StartProgram();
float val = InputValue();
OutputValue(42);
float total = CalculateTotal(1, 2, 3);
char status = DetermineStatus(3.14f);

Tutorial Q1–Q5 Answers

WS6 Q2: Manual Sort Traces

Array: 9, 20, 7, 18, 8, 41, 35, 6, 3, 13

Insertion Sort

Bubble Sort

Selection Sort

88,30,500,70,150,40,8,450,55,150 — Descending

For descending, flip the comparison: swap when left < right (bubble/insertion) or find max instead of min (selection).

Insertion Sort (descending) — after 3 turns:

Pass 1: 88, 30, 500, 70, 150, 40, 8, 450, 55, 150 (no change, 30<88)

Pass 2: 500, 88, 30, 70, 150, 40, 8, 450, 55, 150

Pass 3: 500, 88, 70, 30, 150, 40, 8, 450, 55, 150

After 5 turns:

Pass 4: 500, 150, 88, 70, 30, 40, 8, 450, 55, 150

Pass 5: 500, 150, 88, 70, 40, 30, 8, 450, 55, 150

Q1 Answer: **pp

Given int x; int* p = &x; int ***pp = &p; — to access x's value: **pp (double dereference). Answer is e.

Linear vs Binary (WS6 Q1 — Define)

Linear search: Checks each element one by one from start to end. Simple, works on unsorted arrays, but slow for large datasets O(n).

Binary search: Repeatedly divides the sorted array in half, comparing the target to the middle element. Much faster — O(log n) — but requires a sorted array first.

Everything On One Page

The Exam Function Template

void Name(int[], int);           // prototype
void Name(int ARR[], int SIZE) { // definition
    for(int i=0; i<SIZE; i++)
        scanf("%d", &ARR[i]);
}
Name(ARR, 10);                   // call in main

Never Make These Mistakes