Programming Fundamentals

//  Written 3/3/2018 by Andrew Taylor (andrewt@unsw.edu.au)
//  read characters from stdin and write to stdout
//  except lower case vowels ('a', 'e','i', 'o', 'u') are not written

#include <stdio.h>

int is_vowel(char character);

int main(void) {

    char character;
    while (scanf("%c", &character) == 1) {

        if (!is_vowel(character)) {
            printf("%c", character);
        }
    }

    return 0;
}

// return 1 if character is a lower case vowel
// 0 otherwise
int is_vowel(char character) {
    return character == 'a' ||
           character == 'e' ||
           character == 'i' ||
           character == 'o' ||
           character == 'u';
}

//Prints the first n digits of pi, where n is specified
// by the user
// Liz Willer
// (fake zID: z5255555)
// 2020-03-07

#include <stdio.h>

#define MAX_DIGITS 10

void print_pi_style(int num_digits);

int main(void) {
    printf("How many digits of pi would you like to print? ");
    // TODO: Insert your code here to read in digits
    int digits;
    scanf("%d", &digits);
    // TODO: Call the print_pi_style function you finished
    print_pi_style(digits);

    return 0;
}

void print_pi_style(int num_digits) {
    // DO NOT CHANGE THIS LINE
    int pi[MAX_DIGITS] = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
    // TODO: Finish this function below
    int i = 0;
    while (i < num_digits) {
        if (i == 1) {
            printf(".");
        }
        printf("%d", pi[i]);
        i++;
    }
    printf("\n");
}

// 
// Written 5th March 2022
// By William Setiawan
// (fake zID: z5255555)
// Program which scans a certain number of integers into an array, then prints
// the minimum and maximum values in the array.
//

#include <stdio.h>

#define MAX_SIZE 100

// Given an integer array, iterate over the array and print the minimum and
// maximum values in the array.
void print_array_minmax(int length, int arr[MAX_SIZE]);

int main(void) {
    int scanned_length;
    int length_count = 0;
    int scanned_value;
    int scanned_num[MAX_SIZE];

    // Prompts user for the specific number of integers to be taken from input
    printf("How many numbers: ");
    scanf("%d", &scanned_length);

    // Only takes in scanned_length number of integers
    printf("Please enter numbers: ");
    while (length_count < scanned_length) {
        scanf("%d", &scanned_value);
        scanned_num[length_count] = scanned_value;

        length_count++;
    }
    
    // Print the minimum and maximum values
    print_array_minmax(scanned_length, scanned_num);

    return 0;
}

//////////////////////// DO NOT CHANGE THE CODE BELOW! ////////////////////////

// Given an integer array, iterate over the array and print the minimum and
// maximum values in the array.
//
// Takes in:
// - `length` -- The length of the array.
// - `arr[MAX_SIZE]` -- The integer array to iterate over.
//
// Returns: nothing.
void print_array_minmax(int length, int arr[MAX_SIZE]) {
    int index = 0;
    if (length > 0) {
        int minimum = arr[index];
        int maximum = arr[index];

        while (index < length) {
            if (arr[index] < minimum) {
                minimum = arr[index];
            } else if (arr[index] > maximum) {
                maximum = arr[index];
            }
            
            index++;
        }

        printf("Minimum: %d\nMaximum: %d\n", minimum, maximum);
    }
    
    return;
}

// points.c SOLUTION
// Written 17 June 2023
// By Gab Steiner
//
// This is a c program that scans in points belonging to a shape in a random
// order, then prints them out in the correct order.

#include <stdio.h>

#define MAX_POINTS 10

struct point {
    double x_coord;
    double y_coord;
};


// Prints a point out.
void print_point(int point_no, double x, double y);

int main(void) {

    // Declare an array of points of size MAX_POINTS
    struct point shape[MAX_POINTS];

    printf("How many points in the shape? ");
    // scan in number of points in the shape
    int no_points;
    scanf("%d", &no_points);

    printf("Enter points:\n");
    // scan in the details of each point into the array
    int index = 0;
    while (index < no_points) {
        
        scanf("%lf", &shape[index].x_coord);        // scan the x_coord
        scanf("%lf", &shape[index].y_coord);        // scan the y_coord
        
        index = index + 1;
    }

    printf("\nShape Points:\n");
    // print all the points

    // Go through all the points and print them
    for (int count = 0; count < no_points; count++) {
        print_point(count + 1, shape[count].x_coord, shape[count].y_coord);
    }

    return 0;
}


//  Prints a single point in the correct format.
//
// Parameters:
// - `point_no` -- The point number
// - `x`        -- The x-coordinate of the point
// - `y`        -- The y-coordinate of the point
//
// Returns: nothing.
void print_point(int point_no, double x, double y) {
    
    printf("%2d: x = %.3lf, y = %.3lf\n", point_no, x, y);
}

// Savings Analysis
// savings_analysis.c
//
// This program was written by Morgan Swaak (z5476300)
// on 03/02/24
//
// A program to do analysis on a savings account.

#include <stdio.h>

#define NUM_MONTHS 12

struct transaction {
    int deposits;
    int spending;
};

int calc_yearly_deposits(struct transaction transactions[NUM_MONTHS]);
int calc_yearly_spending(struct transaction transactions[NUM_MONTHS]);
int calc_ending_balance(int starting_balance, struct transaction transactions[NUM_MONTHS]);
int calc_months_saving_goal_met(int saving_goal, struct transaction transactions[NUM_MONTHS]);

// main funciton initalises transactions array and prints results
int main(void) {
    // array initalisation
    int starting_balance;
    int saving_goal;
    struct transaction transactions[NUM_MONTHS]; 
    printf("Please enter starting balance: ");
    scanf("%d", &starting_balance);
    printf("Please enter monthly saving goal: ");
    scanf("%d", &saving_goal);
    printf("Please enter monthly deposits: ");
    int i = 0;
    while (i < NUM_MONTHS) {
        scanf("%d", &transactions[i].deposits);
        i++;
    }
    printf("Please enter monthly spending: ");
    i = 0;
    while (i < NUM_MONTHS) {
        scanf("%d", &transactions[i].spending);
        i++;
    }

    // print out analysis
    int yearly_deposits = calc_yearly_deposits(transactions);
    int yearly_spending = calc_yearly_spending(transactions);
    int ending_balance = calc_ending_balance(starting_balance, transactions);
    int num_months = calc_months_saving_goal_met(saving_goal, transactions);

    printf("\n");
    printf("Yearly deposits = $%d\n", yearly_deposits);
    printf("Yearly spending = $%d\n", yearly_spending);
    printf("Ending balance  = $%d\n", ending_balance);
    printf("You met the monthly saving goal %d times!\n", num_months);
    return 0;
}

// calculates and returns the total amount of money deposited
int calc_yearly_deposits(struct transaction transactions[NUM_MONTHS]) {
    int yearly_deposits = 0;
    int i = 0;
    while (i < NUM_MONTHS) {
        yearly_deposits += transactions[i].deposits;
        i++;
    }
    return yearly_deposits;
}

// calculates and returns the total amount of money spent
int calc_yearly_spending(struct transaction transactions[NUM_MONTHS]) {
    int yearly_spending = 0;
    int i = 0;
    while (i < NUM_MONTHS) {
        yearly_spending += transactions[i].spending;
        i++;
    }
    return yearly_spending;
}

// calculates and returns the ending balance of an account
int calc_ending_balance(
    int starting_balance, 
    struct transaction transactions[NUM_MONTHS]
) {
    return starting_balance + calc_yearly_deposits(transactions) - calc_yearly_spending(transactions);
}

// returns the the number of months the saving goal was met
int calc_months_saving_goal_met(
    int saving_goal, 
    struct transaction transactions[NUM_MONTHS]
) {
    int num_months = 0;
    int i = 0;
    while (i < NUM_MONTHS) {
        if (transactions[i].deposits - transactions[i].spending >= saving_goal) {
            num_months += 1;
        }
        i++;
    }
    return num_months;
}

// Author: Dean Wunder
// d.wunder@unsw.edu.au
// 2020-05-04
// A arbitrary calculator app designed to help students
// understand variable length input scanning before assignment 1.

#include <stdio.h>

#define SQUARE_COMMAND 's'
#define POWER_COMMAND  'p'

int main (void) {

    char command;
    printf("Enter instruction: ");
    while (scanf(" %c", &command) == 1) {
        if (command == SQUARE_COMMAND) {
            int num;
            scanf("%d", &num);
            printf("%d\n", num * num);
        } else if (command == POWER_COMMAND) {
            int base, power;
            scanf("%d %d", &base, &power);
            int i = 0;
            int result = 1;
            while (i < power) {
                result *= base;
                i++;
            }
            printf("%d\n", result);
        }
        printf("Enter instruction: ");
    }

    return 0;
}

// Detective
// detective.c
//
// This program was written by Morgan Swaak (z5476300)
// on 02/02/24
//
// A program to decipher hidden messages in enemy codes.

#include <stdio.h>

#define MAX_SIZE 100

struct code {
    char letter;
    int number;
};

int main(void) {
    //////////////// DO NOT CHANGE ANY OF THE CODE BELOW HERE //////////////////
    struct code message[MAX_SIZE];

    // read in message
    printf("Please enter Encrypted Message: ");
    int i = 0;
    char letter;
    scanf("%c", &letter);
    while(letter != '\n') {
        message[i].letter = letter;
        scanf("%c", &letter);
        i++;
    }

    // read in numbers
    printf("Please enter Secret Numbers: ");
    int j = 0;
    int number;
    scanf("%d", &number);
    message[j].number = number;
    j++;
    while (j != i) {
        scanf("-%d", &number);
        message[j].number = number;
        j++;
    }
    //////////////// DO NOT CHANGE ANY OF THE CODE ABOVE HERE //////////////////

    ////////////////////////////////////////////////////////////////////////////
    ///////////////////// ONLY WRITE CODE BELOW HERE ///////////////////////////
    ////////////////////////////////////////////////////////////////////////////

    printf("Secret Message is: ");

    int index = message[0].number;
    while (message[index].letter != '#') {
        printf("%c", message[index].letter);
        index = message[index].number;
    }
    printf("\n");

    ////////////////////////////////////////////////////////////////////////////
    ///////////////////// ONLY WRITE CODE ABOVE HERE ///////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    return 0;
}

// Written June 2022
// By Enzo Lee Solano (z5258621)
//
// Interactive program to scan in and display the details of students in a 
// class.

#include <stdio.h>

#define MAX_CLASS_SIZE 20
#define MAX_EXAM_MARK 40
#define MAX_ASSIGMENTS_MARK 60
#define NOT_FOUND -1

enum loop_sentinal { STOP_LOOPING, KEEP_LOOPING };
enum command {HELP, PRINT_STUDENT, PRINT_CLASS, QUIT, INVALID_COMMAND };
enum degree_type {UGRD, PGRD, INVALID_DEGREE};
enum major {
    COMPA1,
    COMPD1,
    COMPE1,
    COMPI1,
    COMPJ1,
    COMPN1,
    COMPS1,
    COMPY1,
    NONE
};

struct student {
    int z_id;
    enum major major;
    enum degree_type degree_type;
    double assignments_mark;
    double exam_mark;
    double course_grade;
};

//Additional Helper Functions:
void print_degree_prompt(void);
void print_major_prompt(void);
double clamp_double(double n, double lower, double higher);
void print_class(int class_size, struct student class[MAX_CLASS_SIZE]);
int find_student_index(int z_id, int class_size, 
                       struct student class[MAX_CLASS_SIZE]);
void print_help_prompt(void);
void find_and_print_student(int class_size, 
                            struct student class[MAX_CLASS_SIZE]);


// Required Functions:
void print_degree_type(enum degree_type degree_type);
enum degree_type scan_degree(void);
void print_major(enum major major);
enum major scan_major(void);
struct student scan_student_details(void);
void print_student(struct student student);
enum command scan_command(void);


int main(void) {
    int class_size;
    printf("Enter Class Size: ");
    scanf("%d", &class_size);

    if (class_size <= 0 || class_size > MAX_CLASS_SIZE) {
        printf("Class Size must be between 1 and %d\n", MAX_CLASS_SIZE);
        // Exit the program early
        return 0;
    }

    struct student class[MAX_CLASS_SIZE];

    int i = 0;
    while (i < class_size) {
        printf("Student %d: \n", i + 1);
        class[i] = scan_student_details();
        i++;
    }

    enum loop_sentinal is_looping = KEEP_LOOPING;
    while (is_looping) {
        printf("Enter Command Number (0 for Help): ");

        enum command command = scan_command();
        if (command == HELP) {
            print_help_prompt();
        } else if (command == PRINT_STUDENT) {
            find_and_print_student(class_size, class);
        } else if (command == PRINT_CLASS) {
            print_class(class_size, class);
        } else if (command == QUIT) {
            is_looping = STOP_LOOPING;
        } else {
            printf("Invalid Command\n");
        }
    }

    printf("Exiting Program\n");

    return 0;
}


// Given a `enum degree_type`, prints out the corresponding string.
void print_degree_type(enum degree_type degree_type) {
    if (degree_type == UGRD) {
        printf("Undergraduate\n");
    } else if (degree_type == PGRD) {
        printf("Postgraduate\n");
    } else {
        printf("INVALID\n");
    }
}

// Prints the prompt which explains to the user how to input a degree_type.
void print_degree_prompt(void) {
    printf("Select Degree Type: \n");
    enum degree_type degree_type = UGRD;
    while (degree_type <= PGRD) {
        printf("%d: ", degree_type);
        print_degree_type(degree_type);
        degree_type++;
    }
}

// Scans in a degree as an integer and maps it to the corresponding 
// `enum degree_type`
// returns : INVALID_DEGREE, if the scanned integer does not correspond to a
//           degree type,
//         : else, the corresponding degree_type
enum degree_type scan_degree(void) {

    int scanned_degree_type;
    scanf("%d", &scanned_degree_type);
    enum degree_type degree_type = INVALID_DEGREE;
    if (scanned_degree_type == UGRD || scanned_degree_type == PGRD) {
        degree_type = scanned_degree_type;
    }

    return degree_type;
}



// Given a `enum major`, prints out the corresponding string.
void print_major(enum major major) {
    if (major == COMPA1) {
        printf("Computer Science\n");
    } else if (major == COMPD1) {
        printf("Database Systems\n");
    } else if (major == COMPE1) {
        printf("eCommerce Systems\n");
    } else if (major == COMPI1) {
        printf("Artificial Intelligence\n");
    } else if (major == COMPJ1) {
        printf("Programming Languages\n");
    } else if (major == COMPN1) {
        printf("Computer Networks\n");
    } else if (major == COMPS1) {
        printf("Embedded Systems\n");
    } else if (major == COMPY1) {
        printf("Security Engineering\n");
    } else {
        printf("None\n");
    }
}

// Prints the prompt which explains to the user how to input a major.
void print_major_prompt(void) {
    printf("Select Major: \n");
    enum major major = COMPA1;
    while (major <= NONE) {
        printf("%d: ", major);
        print_major(major);
        major++;
    }
}

// Scans in a COMP/SCI major as an integer and maps it to the corresponding 
// `enum major`
// returns : NONE, if the scanned integer does not correspond to a
//           MAJOR,
//         : else, the corresponding major
enum major scan_major(void) {
    int scanned_major;
    scanf("%d", &scanned_major);
    enum major major = NONE;
    if (scanned_major >= COMPA1 && scanned_major < NONE) {
        major = scanned_major;
    }

    return major;
}

// Clamps n in the range lower <= n <= higher
// Parameters
//      n     : the number to clamp
//      lower : the lower bound
//      higher: the upper bound
//
// returns : the clamped value.
double clamp_double(double n, double lower, double higher) {
    double clamped_n = n;
    if (n > higher) {
        clamped_n = higher;
    } else if (n < lower) {
        clamped_n = lower;
    }

    return clamped_n;
}

// Scans in all the details for a single student, and returns the details as a
// `struct student`.
//
// returns : the new struct student.
struct student scan_student_details(void) {
    struct student new_student;
    printf("Enter zID: ");
    scanf("%d", &new_student.z_id);

    print_degree_prompt();
    new_student.degree_type = scan_degree();

    new_student.major = NONE;
    if (new_student.degree_type == UGRD) {
        print_major_prompt();
        new_student.major = scan_major();
    }

    printf("Enter Assignments mark (out of %d): ", MAX_ASSIGMENTS_MARK);
    double assignments_mark;
    scanf("%lf", &assignments_mark);
    assignments_mark = clamp_double(assignments_mark, 0, MAX_ASSIGMENTS_MARK);

    printf("Enter exam mark (out of %d): ", MAX_EXAM_MARK);
    double exam_mark;
    scanf("%lf", &exam_mark);
    exam_mark = clamp_double(exam_mark, 0, MAX_EXAM_MARK);

    new_student.assignments_mark = assignments_mark;
    new_student.exam_mark = exam_mark;
    new_student.course_grade = exam_mark + assignments_mark;

    return new_student;
}

// Given a `struct student`, prints out the formatted details of the student.
void print_student(struct student student) {
    printf("z%07d: {\n", student.z_id);
    printf("\tDegree Type: ");
    print_degree_type(student.degree_type);

    if (student.degree_type == UGRD) {
        printf("\tMajor: ");
        print_major(student.major);
    }

    printf("\tAssignments Mark: %3.02lf/%d\n", student.assignments_mark, 
           MAX_ASSIGMENTS_MARK);
    printf("\tExam Mark: %3.02lf/%d\n", student.exam_mark, MAX_EXAM_MARK);
    printf("\tCourse Grade: %3.02lf/%d\n", student.course_grade, 
           MAX_ASSIGMENTS_MARK + MAX_EXAM_MARK);
    printf("}\n");
}

// Given an array of `struct student`s, prints out the formatted details 
// all students in the array.
void print_class(int class_size, struct student class[MAX_CLASS_SIZE]) {
    printf("Students: \n");
    int i = 0;
    while (i < class_size) {
        print_student(class[i]);
        i++;
    }
}

// Given a specific zID, finds and returns the index of the corresponding 
// student.
// Parameters
//      z_id       : the zID of the student to find
//      class_size : the number of students in the class
//      class      : an array of students
//
// returns : NOT_FOUND, if `z_id` does not correspond to a student in the array.
//         : the index of the first occurance of a student with zID: `z_id`,
//           otherwise.
int find_student_index(int z_id, int class_size, 
                       struct student class[MAX_CLASS_SIZE]) {
    int i = 0;
    int student_index = NOT_FOUND;
    while (i < class_size) {
        if (class[i].z_id == z_id) {
            student_index = i;
        }
        i++;
    }

    return student_index;
}


// Prints the prompt which explains to the user how to input different commands
void print_help_prompt(void) {
    printf("Enter a number corresponding to one of the following commands: \n");
    printf("0 (Help): Display program instructions\n");
    printf("1 (Display Student): Print the details of a specific student\n");
    printf("2 (Display Class): Print the details of all students in a class\n");
    printf("3 (Quit): Exit the program\n");
}


// Scans in a command as an integer and maps it to the corresponding 
// `enum command`
// returns : INVALID_COMMAND, if the scanned integer does not correspond to a
//           command,
//         : else, the corresponding command
enum command scan_command(void) {

    int scanned_command;
    scanf("%d", &scanned_command);
    enum command command = INVALID_COMMAND;
    if (scanned_command >= HELP && scanned_command <= QUIT) {
        command = scanned_command;
    }

    return command;
}

// Scans in a zID and displays the details of the corresponding student in a 
// given class.
//
// Parameters
//      class_size : the number of students in the class
//      class      : an array of students
void find_and_print_student(int class_size, struct student class[MAX_CLASS_SIZE]) {
    printf("Enter Student zID: ");
    int z_id;
    scanf("%d", &z_id);
    int student_index = find_student_index(z_id, class_size, class);

    if (student_index == NOT_FOUND) {
        printf("No student with that zID exists\n");
    } else {
        print_student(class[student_index]);
    }
}

// debug_letter_search.c SOLUTION
//
// Write a C program that takes in a letter from the user, and then searches 
// more input given by the user for that letter, or until CTRL+D is entered.
//
// Gab Steiner, June 2023

#include <stdio.h>

#define TRUE 1
#define FALSE 0

int main(void) {
    // Get the letter we are trying to find
    printf("Which letter are we searching for?: ");
    char target;
    scanf("%c", &target);

    // Loop through input until we get the target, or ctrl+d
    char letter;
    int found = FALSE;
    while (found == FALSE && scanf("%c", &letter) == 1) {
        // Check if we found the letter
        if (letter == target) {
            found = TRUE;
        }
    }

    // Tell the user if we found it or not
    if (found == TRUE) {
        printf("We found %c!!!\n", target);
    } else {
        printf("The mission was not successful :(\n");
    }

    return 0;
}

// debug_cloud.c SOLUTION
// This is a C program that reads in some clouds and tallies the types.
// Gab Steiner, June 2023

#include <stdio.h>

enum levels {
    LOW = 500,
    MID = 2000,
    HIGH = 6000
};

enum cloud_type {
    FOG,
    CUMULO,
    ALTO,
    CIRRO
};

struct cloud {
    double height;
    enum cloud_type type;
};

int cloud_type_count(enum cloud_type type, struct cloud clouds[10], 
                            int count);

int main(void) {
    struct cloud sky[10];    

    printf("Enter some clouds:\n");
    // Scan in some clouds
    int index = 0;
    while (scanf("%lf", &sky[index].height) == 1) {

        // Determine the type of cloud based on it's height
        if (sky[index].height > HIGH) {
            sky[index].type = CIRRO;
        } else if (sky[index].height > MID) {
            sky[index].type = ALTO;
        } else if (sky[index].height > LOW) {
            sky[index].type = CUMULO;
        } else {
            sky[index].type = FOG;
        }

        index++;
    }

    // Print out the total for each cloud
    printf("\nCLOUDS\n");
    printf("There are %d fog clouds\n", cloud_type_count(FOG, sky, index));
    printf("There are %d cumulo clouds\n", cloud_type_count(CUMULO, sky, index));
    printf("There are %d alto clouds\n", cloud_type_count(ALTO, sky, index));
    printf("There are %d cirro clouds\n", cloud_type_count(CIRRO, sky, index));

    return 0;
}

// This function counts the number of times a specific type of cloud was seen.
//
// ARGS:
// - type is the type of cloud being looked for.
// - clouds is an array of cloud structs.
// - count is the number of clouds filled in the array.
//
// RETURN:
// - total is the number of clouds of the specific type that were found.
//
int cloud_type_count(enum cloud_type type, struct cloud clouds[10], 
                            int count) {
    
    int total = 0;

    // Find all the clouds with that type
    for (int i = 0; i < count; i++) {
        if (clouds[i].type == type) {
            total++;
        }
    }

    return total;
}