Programming Fundamentals

#include <stdio.h>

// start with constants, then move to enums
// #define MONDAY 0
// #define TUESDAY 1
// #define WEDNESDAY 2
// #define THURSDAY 3
// #define FRIDAY 4

// [TUTOR NOTE] Start off with constants for the days of the week
// [TUTOR NOTE] Since they are part of a set, we can link them together under the one enum, enum weekday
// [TUTOR NOTE] Create the enum,
// [TUTOR NOTE] Enums are of type int, and are similar to constants, but they are automatically assigned values.
// [TUTOR NOTE] Makes the code much easier to read & maintain
// [TUTOR NOTE] Demonstrate how they start at 0 but this can be edited (e.g. change to MONDAY = 1)
enum weekday {
	MONDAY,
	TUESDAY,
	WEDNESDAY,
	THURSDAY,
	FRIDAY,
	SATURDAY,
	SUNDAY
};

int main(void) {
	// [TUTOR NOTE] Change lecture to an enum, and declare & initialise one for tutorial (the scanned input).
	enum weekday lecture = MONDAY;
	
	// [TUTOR NOTE] Optional: fix up style by showing how to shorten a long printf() (also a common question)
	printf("Please enter the day of the week your tutorial is on:\n0: Monday\n1: Tuesday\n2: Wednesday\n4: Thursday\n5: Friday\n");
	int day;

	// [TUTOR NOTE] Explain that you cannot scan directly into an enum, and have to scan into an int first
	// [TUTOR NOTE] Emphasise the type is enum weekday (there’s usually a lot of confusion on the type & naming for enums & structs)
	scanf("%d", &day);

	enum weekday tutorial = day;

	if (tutorial == MONDAY) {
		printf("Your tutorial is on Monday!\n");
	} else if (tutorial == TUESDAY) {
		printf("Your tutorial is on Tuesday!\n");
	}

	return 0;
}

// [TUTOR NOTE] Ask for examples of other enum applications

#include <stdio.h>

// [TUTOR NOTE] This includes the enum weekday from the enum exercise 
// 		- to keep things simple you can add the enum weekday in at the end, 
//		and leave it out for the initial struct explanation 
enum weekday {
	MONDAY,
	TUESDAY,
	WEDNESDAY,
	THURSDAY,
	FRIDAY,
	SATURDAY,
	SUNDAY
};

// [TUTOR NOTE] Explain that structs group different but related variables 
//		(of same or different types) into one structure
struct tutorial {
	enum weekday day;
	int time;
	char stream;
	int num_students;
};

int main(void) {
	// [TUTOR NOTE] Start off with variables
	// [TUTOR NOTE] Since these variables together make up the details for a 
	// 		tutorial, they’re perfect for a struct tutorial
	// [TUTOR NOTE] Create the struct tutorial

	// [TUTOR NOTE] Define & initialise a struct tutorial called my_tutorial instead of the variables, explaining the syntax
	struct tutorial my_tutorial;
	my_tutorial.day = TUESDAY;
	my_tutorial.time = 15;
	my_tutorial.stream = 'A';
	my_tutorial.num_students = 25;

	// [TUTOR NOTE] Ask students to help fix up the rest of the code
	printf("Time: %d, Stream: %c.\n", my_tutorial.time, my_tutorial.stream);

	if (my_tutorial.day == MONDAY) {
		printf("Your tutorial is on Monday!\n");
	} else if (my_tutorial.day == TUESDAY) {
		printf("That time is full! Please enter a new time! ");
		scanf("%d", &my_tutorial.time);

		printf("Your new time is: %d\n", my_tutorial.time);
	}

	return 0;
}

// [TUTOR NOTE] Ask for examples of other struct applications

#include <stdio.h>

#define SIZE 10

// [TUTOR NOTE] Go through each scenario, taking suggestions. For the first 
//      couple explain the syntax of while loops. Diagrams/stepping through the 
//      code by hand will be helpful

int main(void) {
    printf("Part 1:\n");
    int count = 0;
    while (count < SIZE) {
        // print every number
        // printf("%d ", count);

        // print numbers divisible by 2
        if (count % 2 == 0) {
            printf("%d ", count);
        }
        count++;
    }
    printf("\n");

    // [TUTOR NOTE] Emphasise the importance of initialising row & col correctly, 
    //      as well as incrementing properly (show an infinite loop & how to stop them)
    printf("Part 2:\n");
    // print a SIZE * SIZE grid of X's.
    int row = 0;
    while (row < SIZE) {
        int col = 0;
        while (col < SIZE) {
            printf("X ");
            col++;
        }
        printf("\n");
        row++;
    }

    printf("Part 3:\n");
    // print every odd column as O's, every where else as X's.
    row = 0;
    while (row < SIZE) {
        int col = 0;
        while (col < SIZE) {
            if (col % 2 == 1) {
                printf("O ");
            } else {
                printf("X ");
            }
            col++;
        }
        printf("\n");
        row++;
    }

    // [TUTOR NOTE] The last one is not as important - it’s more problem solving 
    //      by that point than while loop logic
    printf("Part 4:\n");
    // print the diagonals as O's, everywhere else as X's.
    row = 0;
    while (row < SIZE) {
        int col = 0;
        while (col < SIZE) {
            if (row == col || row + col == SIZE - 1) {
                printf("O ");
            } else {
                printf("X ");
            }
            col++;
        }
        printf("\n");
        row++;
    }
}

#include <stdio.h>

// [TUTOR NOTE] Hint that this will be helpful for this week’s labs devowel & cs_calculator

int main(void) {
    printf("Enter a number: ");
    int number;
    scanf("%d", &number);

    printf("The number was %d\n", number);

    // create a loop that scans 1 number repeatedly until the user hits CTRL + D
    // [TUTOR NOTE] Before creating a loop, explain that scanf() has a return 
    //      value, and that it is the number of items successfully scanned & stored
    // [TUTOR NOTE] Ask what they think scanf() returns when you enter a number, 
    //      a character, and CTRL + D
    // [TUTOR NOTE] Go through those inputs and explain them (can pull up the man 
    //      pages if they’re following along well/want more explanation)

    // [TUTOR NOTE] Create a loop to scan until CTRL + D the long way (using 
    //      scanf() return), then simplify so scanf() is in the while loop itself
    int scanf_return = scanf("%d", &number);
    while (scanf_return == 1) {
        printf("The number was %d\n", number);
        scanf_return = scanf("%d", &number);
    }

    // [TUTOR NOTE] Change the loop to scan in 2 numbers at a time instead 
    //      (so they can see 1 change to 2)
    
    // // final:
    // while (scanf("%d", &number) == 1) {
    //     printf("The number was %d\n", number);
    // }

    // // create a loop that scans 2 numbers repeatedly until the user hits CTRL + D
    // int number_2;
    // while (scanf("%d %d", &number, &number_2) == 2) {
    //     printf("The numbers were %d and %d\n", number, number_2);
    // }
}

// [TUTOR NOTE] If they are following along well, it’s a good opportunity to 
//      introduce the man pages with man scanf, especially showing the return value section

// Solution to guessing_cards.c with functions

#include <stdio.h>

#define MAX_TURNS 5
#define TRUE 1
#define FALSE 0

// [TUTOR NOTE] This should be done after enums.c & structs.c, some extra practice
// [TUTOR NOTE] Hopefully the students should be able to take the lead on this one, 
//      so take suggestions from them
// [TUTOR NOTE] Involves: scanning into structs, altering a field in a struct, 
//      while loops (count & sentinel), if/else
// [TUTOR NOTE] After solving everything in main, can demonstrate moving similar 
//      sections into functions (in my solution I use 3 - initialise_card, update_points & print_end)

enum suit {
    DIAMOND,
    CLUB,
    HEART,
    SPADE
};

struct card {
    int number;
    enum suit suit;
    int points;
};

struct card initialise_card(int player_num);
struct card update_points(struct card p1,
                          struct card p2,
                          int num,
                          enum suit suit);
void print_end(struct card p1, struct card p2);

int main(void) {
    struct card player1 = initialise_card(1);
    struct card player2 = initialise_card(2);

    int turns = 0;
    int game_end = FALSE;
    while (turns < MAX_TURNS && !game_end) {
        printf("\nRound %d!\n", turns + 1);

        int number;
        int suit;
        printf("Player 1, please guess player 2's card: ");
        scanf("%d %d", &number, &suit);

        if (player2.number == number && player2.suit == suit) {
            game_end = TRUE;
        }
        player1 = update_points(player1, player2, number, suit);

        printf("Player 2, please guess player 1's card: ");
        scanf("%d %d", &number, &suit);

        if (player1.number == number && player1.suit == suit) {
            game_end = TRUE;
        }
        player2 = update_points(player2, player1, number, suit);

        printf("Player 1: %d, Player 2: %d\n", player1.points, player2.points);
        turns++;
    }

    print_end(player1, player2);

    return 0;
}

struct card initialise_card(int player_num) {
    struct card player;
    int suit;
    printf("Player %d, please enter your card number & suit: ", player_num);
    scanf("%d %d", &player.number, &suit);
    player.suit = suit;
    player.points = 0;
    return player;
}

struct card update_points(struct card p1,
                          struct card p2,
                          int num,
                          enum suit suit) {
    if (p2.number == num) {
        p1.points++;
    } 
    if (p2.suit == suit) {
        p1.points++;
    }
    return p1;
}

void print_end(struct card p1, struct card p2) {
    printf("Game over! ");
    if (p1.points == p2.points) {
        printf("It's a draw!\n");
    } else if (p1.points > p2.points) {
        printf("Player 1 wins!\n");
    } else {
        printf("Player 2 wins!\n");
    }
}

// Program to scan in three integers and print out the middle one.

#include <stdio.h>

struct numbers {
    int first;
    int second;
    int third;
};

int main(void) {
    // DO NOT CHANGE CODE BELOW HERE
    struct numbers nums;
    printf("Enter integer: ");
    scanf("%d", &nums.first);

    printf("Enter integer: ");
    scanf("%d", &nums.second);

    printf("Enter integer: ");
    scanf("%d", &nums.third);
    // DO NOT CHANGE CODE ABOVE HERE

    // ADD CODE BELOW HERE
    int middle = nums.first;
    if (nums.first > nums.second) {
        // third second first
        if (nums.second > nums.third) {
            middle = nums.second;
        // second third first
        } else if (nums.first > nums.third) {
            middle = nums.third;
        }
    } else {
        // first second third
        if (nums.third > nums.second) {
            middle = nums.second;
        // first third second
        } else if (nums.third > nums.first) {
            middle = nums.third;
        }
    }

    printf("Middle: %d\n", middle);
    return 0;
}

// Read numbers in a loop, and calculate their sum.
// A sample solution.

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

int read_num(void);

int main(void) {
    printf("How many numbers: ");
    int amount = read_num();

    int sum = 0;
    int i = 0;
    while (i < amount) {
        sum += read_num();
        i++;
    }

    printf("The sum is: %d\n", sum);

    return 0;
}

// Note: you did not need to check that scanf succeeds for this exercise.
int read_num(void) {
    int num;
    if (scanf("%d", &num) != 1) {
        printf("Could not read a number\n");
        exit(EXIT_FAILURE);
    }
    return num;
}

// Program to print out an hourglass shape given an
// input size.
// Written by Rory Golledge (June 2021)

#include <stdio.h>

int main(void) {
    int input;
    printf("Please enter a size: ");
    scanf("%d", &input);

    int row = 0;
    while (row < input) {
        int col = 0;
        while (col < input) {
            // Take care of Top-half triangle
            if (row < input / 2) {
                if (row <= col && row + col <= input - 1) {
                    printf("*");
                } else {
                    printf("-");
                }
            }
            // Take care of Bottom-half triangle
            else {
                if (row >= col && row + col >= input - 1) {
                    printf("*");
                } else {
                    printf("-");
                }
            }

            col++;
        }
        printf("\n");
        row++;
    }

    return 0;
}

int count_bigger(int length, int array[length]) {
    int bigger = 0;

    int i = 0;
    while (i < length) {
        if (array[i] > 99 || array[i] < -99) {
            bigger = bigger + 1;
        }
        i = i + 1;
    }

    return bigger;
}

// Some useful array functions
// Sample solution.

#include <assert.h>
#include <stdio.h>

#define SMALL_ARRAY 5
#define MEDIUM_ARRAY 20
#define LARGE_ARRAY 200

// Display useful facts about the array (changes the array).
void array_facts(int size, int array[]);

// Reading and showing arrays.
void scan_array(int size, int array[]);
void show_array(int size, int array[]);

// Array functions without side effects.
int array_max(int size, int array[]);
int array_min(int size, int array[]);
int array_sum(int size, int array[]);
int array_average(int size, int array[]);

// Changing the whole array.
void array_add(int size, int array[], int num);
void array_scale(int size, int array[], int num);

int main(int argc, char *argv[]) {
    // Create an array with 5 elements.
    int array_a[SMALL_ARRAY] = {1, 2, 3, 4, 5};

    // Assert the min, max, and sum are what we expect.
    assert(array_min(SMALL_ARRAY, array_a) == 1);
    assert(array_max(SMALL_ARRAY, array_a) == 5);
    assert(array_sum(SMALL_ARRAY, array_a) == 15);
    assert(array_average(SMALL_ARRAY, array_a) == 3);

    // Add 1 to all of the values in the array.
    array_add(SMALL_ARRAY, array_a, 1);

    // Check the min/max/sum/average again.
    assert(array_min(SMALL_ARRAY, array_a) == 2);
    assert(array_max(SMALL_ARRAY, array_a) == 6);
    assert(array_sum(SMALL_ARRAY, array_a) == 20);
    assert(array_average(SMALL_ARRAY, array_a) == 4);

    // Create a medium-sized array to perform more unit tests.
    int array_b[MEDIUM_ARRAY] = {0};
    int b = 0;
    while (b < MEDIUM_ARRAY) {
        array_b[b] = b * b;
        b = b + 1;
    }

    // Check that the min/max/sum/average are what we'd expect.
    assert(array_min(MEDIUM_ARRAY, array_b) == 0);
    assert(array_max(MEDIUM_ARRAY, array_b) == 361);
    assert(array_sum(MEDIUM_ARRAY, array_b) == 2470);
    assert(array_average(MEDIUM_ARRAY, array_b) == 123);

    // Scale the array by -2, and then re-check the min/max/sum/average.
    array_scale(MEDIUM_ARRAY, array_b, -2);
    assert(array_min(MEDIUM_ARRAY, array_b) == -722);
    assert(array_max(MEDIUM_ARRAY, array_b) == 0);
    assert(array_sum(MEDIUM_ARRAY, array_b) == -4940);
    assert(array_average(MEDIUM_ARRAY, array_b) == -247);

    // Test an array with manual values
    int manual_array[MEDIUM_ARRAY] = {0};
    scan_array(MEDIUM_ARRAY, manual_array);
    array_facts(MEDIUM_ARRAY, manual_array);

    printf("All tests passed. You are Awesome!");

    return 0;
}

// Display some useful facts about an array.
// NOTE: this will change the array that is used.
void array_facts(int size, int array[]) {
    printf("The largest value in the array is %d\n",
            array_max(size, array));
    printf("The smallest value in the array is %d\n",
            array_min(size, array));
    printf("The sum of all values in the array is %d\n",
            array_sum(size, array));
    printf("The average value in the array is %d\n",
            array_average(size, array));

    int s = 0;
    while (s < 5) {
        printf("The array with %d added to all elements:\n", s);
        array_add(size, array, s);
        show_array(size, array);
        s = s + 1;
    }

    printf("The array with 10 subtracted from all elements:\n");
    array_add(size, array, -10);
    show_array(size, array);

    int m = 1;
    while (m <= 5) {
        printf("The array with all elements multiplied by %d:\n", m);
        array_scale(size, array, m);
        show_array(size, array);
        m = m + 1;
    }
}

// Read values from the screen, and store the values in an array.
void scan_array(int size, int array[]) {
    printf("Enter %d numbers: ", size);
    int i = 0;
    while (i < size) {
        scanf("%d", &array[i]);
        i = i + 1;
    }
}

// Show an array on the screen.
// This should look like [0, 1, 2, 3, 4, 5]
void show_array(int size, int array[]) {
    printf("[");
    int i = 0;
    while (i < size) {
        printf("%d", array[i]);
        i = i + 1;

        // Add the comma and space
        if (i != size) {
            printf(", ");
        }
    }
    printf("]\n");
}

// Return the largest value in an array.
int array_max(int size, int array[]) {
    int max = array[0];
    int i = 0;
    while (i < size) {
        if (array[i] > max) {
            max = array[i];
        }
        i = i + 1;
    }
    return max;
}

// Return the smallest value in the array.
int array_min(int size, int array[]) {
    int min = array[0];
    int i = 0;
    while (i < size) {
        if (array[i] < min) {
            min = array[i];
        }
        i = i + 1;
    }
    return min;
}

// Return the sum of all values in the array.
int array_sum(int size, int array[]) {
    int sum = 0;
    int i = 0;
    while (i < size) {
        sum += array[i];
        i = i + 1;
    }
    return sum;
}

// Return the average of all values in the array.
int array_average(int size, int array[]) {
    return array_sum(size, array) / size;
}

// Add num to all values in the array.
void array_add(int size, int array[], int num) {
    int i = 0;
    while (i < size) {
        array[i] += num;
        i = i + 1;
    }
}

// Multiply all values in the array by num.
void array_scale(int size, int array[], int num) {
    int i = 0;
    while (i < size) {
        array[i] *= num;
        i = i + 1;
    }
}

int common_elements(int length, int source1[length], int source2[length], int destination[length]) {
    int upto = 0;
    int a1 = 0;
    while (a1 < length) {
        int found = 0;
        int a2 = 0;
        while (a2 < length && !found) {
            if (source1[a1] == source2[a2]) {
                found = 1;
            }
            a2 = a2 + 1;
        }
        if (found) {
            destination[upto] = source1[a1];
            upto = upto + 1;
        }
        a1 = a1 + 1;
    }
    return upto;
}