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;
}

// Rewrite Letters
// rewrite_letters.c
//
// This program was written by Andrew Polak (fake zid z9999999)
// on 12-Jan-2025.
//
// A program which reads in an array of initial letters, then rewrites each
// occurrence of two chosen letters with corresponding sequences of letters.
//
// Example:
// 
// $ ./rewrite_letters
// Initial letters: All X are Y, but not all Y are X.
// 1st letter to be rewritten: X
// 1st rewriting rule: cats
// 2nd letter to be rewritten: Y
// 2nd rewriting rule: gravity-testers who push things off tables
// All cats are gravity-testers who push things off tables, but not all
//   gravity-testers who push things off tables are cats.
//


#include <stdio.h>

#define MAX_LENGTH 1024

////////////////////////////////////////////////////////////////////////////////
// Function Prototypes
////////////////////////////////////////////////////////////////////////////////

int scan_char_array(char array[MAX_LENGTH]);

////////////////////////////////////////////////////////////////////////////////
// Main Function
////////////////////////////////////////////////////////////////////////////////

int main(void) {
    // scan the initial letters into an array & keep track of how many there are
    printf("Initial letters: ");
    char initial_letters[MAX_LENGTH];
    int num_of_initial_chars = scan_char_array(initial_letters);

    // get the first letter to be replaced/rewritten
    printf("1st letter to be rewritten: ");
    char letter_1;
    scanf("%c", &letter_1);

    // scan the first rewriting rule into an array & keep track of its length
    printf("1st rewriting rule: ");
    char rule_1[MAX_LENGTH];
    int rule_1_length = scan_char_array(rule_1);

    // get the second letter to be replaced/rewritten
    printf("2nd letter to be rewritten: ");
    char letter_2;
    scanf("%c", &letter_2);

    // scan the second rewriting rule into an array & keep track of its length
    printf("2nd rewriting rule: ");
    char rule_2[MAX_LENGTH];
    int rule_2_length = scan_char_array(rule_2);

    // print out the initial letters, but with every 'letter_to_be_written'
    // replaced by the letters in the rewriting rule
    int i = 0;
    while (i < num_of_initial_chars) {
        if (initial_letters[i] == letter_1) {
            // write rule_1 instead of letter_1
            for (int rule_index = 0; rule_index < rule_1_length; rule_index++) {
                printf("%c", rule_1[rule_index]);
            }
        } else if (initial_letters[i] == letter_2) {
            // write rule_2 instead of letter_2
            for (int rule_index = 0; rule_index < rule_2_length; rule_index++) {
                printf("%c", rule_2[rule_index]);
            }
        } else {
            // write letter without replacement
            printf("%c", initial_letters[i]);
        }
        i++;
    }
    printf("\n");

    return 0;
}


////////////////////////////////////////////////////////////////////////////////
// Fuction Definitions
////////////////////////////////////////////////////////////////////////////////

// Reads up to MAX_LENGTH characters from stdin and stores them in 'array'.
// Returns the number of characters that were stored.
int scan_char_array(char array[MAX_LENGTH]) {
    int array_length = 0;

    int i = 0;
    char c;
    scanf(" %c", &c);
    while (c != '\n' && i < MAX_LENGTH) {
        array[i] = c;
        i++;
        scanf("%c", &c);
    }
    array_length = i;

    return array_length;
}

// 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;
}

// Fractal Turtle
// fractal_turtle.c
//
// This program was written by Andrew Polak (fake zid z9999999)
// on 12-Jan-2025.
//
// NOTES:
//  - This activity is an extension of the "rewrite_letters" activity.
//  - This solution uses string functions (e.g. fgets(), strncpy()) as a matter
//    of convenience, but they are not required. See the solution to
//    "rewrite_letters" for how to handle arrays of chars without strings.
//
// A program which generates strings with Lindenmayer Systems (L-Systems) and
// paints their turtle interpretation to the terminal.
//
// The principles implemented by this program are inspired by
// "The Algorithmic Beauty of Plants" by Prusinkiewicz and Lindenmayer.
//

// Lindenmayer Systems:
//
// A Lindenmayer system consists of:
//  - An initial string e.g. 
//      "a"
//  - Rewriting rules in the form of predecessor:"successor" e.g.
//      a:"acb"
//      b:"baab"
// Every occurrence of a predecessor in the initial string is replaced with the
// corresponding successor in parallel (at the same time). This can be repeated
// multiple times to generate increasingly longer (or shorter) strings:
//  - Initial String: "a"
//  - 1st rewrite: "acb"
//  - 2nd rewrite: "acbcbaab"
//  - 3rd rewrite: "acbcbaabcbaabacbacbbaab"
//

// Turtle Interpretations:
//
// A Turtle interpretation of a string is named as though there is a turtle
// located on a drawing canvas (i.e. the terminal). It initially faces up 
// towards the top of the screen, then reads characters from the string an
// moves according to a set of rules:
//   "F" means "move forward two steps, painting a line"
//   "f" means "move forward two steps, without painting a line"
//   "-" means "turn right"
//   "+" means "turn left"
// In this way, and string consisting of characters {F, f, -, +} can be drawn on
// the terminal. When the turtle paints a line, it writes characters to the
// terminal. When the turtle moves without painting a line, it writes spaces.
// 
// For example, the sequence of characters "F-F-F-F" draws a square:
//   Initially, the turtle faces up
//   'F' means "draw a line up"
//   '-' means "turn to the right"
//   'F' means "draw a line right"
//   '-' means "turn downwards"
//   'F' means" draw a line down"
//   '-' means "turn to the left"
//   'F' means "draw a line to the left"

// Combining L-Systems with Turtle Interpretations:
//
// If an L-System produces a sequence of characters {F, f, -, +}, then it can be
// drawn on the terminal with a turtle interpretation. That's what this
// program does.
//
// Examples:

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F           
// Rewriting rule for 'F': F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F
// Rewrite 1: F
//  #
//  #
//  #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-F
// Rewriting rule for 'F': F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-F
// Rewrite 1: F-F
//  # # #
//  #    
//  #  

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': FF
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F
// Rewrite 1: FF
//  #
//  #
//  #
//  #
//  #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-FfF-F
// Rewriting rule for 'F': F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-FfF-F
// Rewrite 1: F-FfF-F
//  # # #   # # #
//  #           #
//  #           #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-FfF-F
// Rewriting rule for 'F': FF
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-FfF-F
// Rewrite 1: FF-FFfFF-FF
//  # # # # #   # # # # #
//  #                   #
//  #                   #
//  #                   #
//  #                   #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-FfF-F
// Rewriting rule for 'F': FF
// Rewriting rule for 'f': ffff
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-FfF-F
// Rewrite 1: FF-FFffffFF-FF
//  # # # # #               # # # # #
//  #                               #
//  #                               #
//  #                               #
//  #                               #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-F-F-F
// Rewriting rule for 'F': F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-F-F-F
// Rewrite 1: F-F-F-F
//  # # #
//  #   #
//  # # #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-F-F-F
// Rewriting rule for 'F': FF
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-F-F-F
// Rewrite 1: FF-FF-FF-FF
//  # # # # #
//  #       #
//  #       #
//  #       #
//  # # # # #

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': F-F+F+FF-F-F+F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F
// Rewrite 1: F-F+F+FF-F-F+F
//      #    
//      #    
//  # # #    
//  #        
//  # # # # #
//          #
//      # # #
//      #    
//      #    

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': F-F+F+FF-F-F+F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 2
// Rewrite 0: F
// Rewrite 1: F-F+F+FF-F-F+F
// Rewrite 2: F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F+F-F+F+FF-F-F+FF-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F
//                      #                    
//                      #                    
//                  # # #                    
//                  #                        
//                  # # # # #                
//                          #                
//              # # #   # # #                
//              #   #   #                    
//      # # #   #   # # #                    
//      #   #   #                            
//  # # #   # # #                            
//  #                                        
//  # # # # #                                
//          #                                
//      # # #   # # #           # # #        
//      #       #   #           #   #        
//      # # #   #   # # # # #   #   # # #    
//          #   #           #   #       #    
//          # # #           # # #   # # #    
//                                  #        
//                                  # # # # #
//                                          #
//                              # # #   # # #
//                              #   #   #    
//                      # # #   #   # # #    
//                      #   #   #            
//                  # # #   # # #            
//                  #                        
//                  # # # # #                
//                          #                
//                      # # #                
//                      #                    
//                      #          

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-F-F-F
// Rewriting rule for 'F': F-F+F+FF-F-F+F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-F-F-F
// Rewrite 1: F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F
//              # # #        
//              #   #        
//      # # #   #   # # #    
//      #   #   #       #    
//  # # #   # # #   # # #    
//  #               #        
//  # # # # #       # # # # #
//          #               #
//      # # #   # # #   # # #
//      #       #   #   #    
//      # # #   #   # # #    
//          #   #            
//          # # #   

// 
// This is the same as above, but applying the rewriting rule TWICE
//
// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-F-F-F
// Rewriting rule for 'F': F-F+F+FF-F-F+F
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 2
// Rewrite 0: F-F-F-F
// Rewrite 1: F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F
// Rewrite 2: F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F+F-F+F+FF-F-F+FF-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F+F-F+F+FF-F-F+FF-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F+F-F+F+FF-F-F+FF-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F+F-F+F+FF-F-F+FF-F+F+FF-F-F+F-F-F+F+FF-F-F+F-F-F+F+FF-F-F+F+F-F+F+FF-F-F+F
//                                                              # # #                                        
//                                                              #   #                                        
//                                                      # # #   #   # # #                                    
//                                                      #   #   #       #                                    
//                                                  # # #   # # #   # # #                                    
//                                                  #               #                                        
//                                                  # # # # #       # # # # #                                
//                                                          #               #                                
//                              # # #                   # # #           # # #   # # #                        
//                              #   #                   #               #       #   #                        
//                      # # #   #   # # #               #               # # #   #   # # #                    
//                      #   #   #       #               #                   #   #       #                    
//                  # # #   # # #   # # #           # # #                   # # #   # # #                    
//                  #               #               #                               #                        
//                  # # # # #       # # # # #       # # # # #                       # # # # #                
//                          #               #               #                               #                
//              # # #   # # #           # # #   # # #   # # #                   # # #   # # #                
//              #   #   #               #       #   #   #                       #   #   #                    
//      # # #   #   # # #               # # #   #   # # #               # # #   #   # # #                    
//      #   #   #                           #   #                       #   #   #                            
//  # # #   # # #                           # # #                   # # #   # # #                            
//  #                                                               #                                        
//  # # # # #                                                       # # # # #                                
//          #                                                               #                                
//      # # #   # # #           # # #                                   # # #   # # #           # # #        
//      #       #   #           #   #                                   #       #   #           #   #        
//      # # #   #   # # # # #   #   # # #                               # # #   #   # # # # #   #   # # #    
//          #   #           #   #       #                                   #   #           #   #       #    
//          # # #           # # #   # # #                                   # # #           # # #   # # #    
//                                  #                                                               #        
//                                  # # # # #                                                       # # # # #
//                                          #                                                               #
//                              # # #   # # #                   # # #                           # # #   # # #
//                              #   #   #                       #   #                           #   #   #    
//                      # # #   #   # # #               # # #   #   # # #               # # #   #   # # #    
//                      #   #   #                       #   #   #       #               #   #   #            
//                  # # #   # # #                   # # #   # # #   # # #           # # #   # # #            
//                  #                               #               #               #                        
//                  # # # # #                       # # # # #       # # # # #       # # # # #                
//                          #                               #               #               #                
//                      # # #   # # #                   # # #           # # #   # # #   # # #                
//                      #       #   #                   #               #       #   #   #                    
//                      # # #   #   # # #               #               # # #   #   # # #                    
//                          #   #       #               #                   #   #                            
//                          # # #   # # #           # # #                   # # #                            
//                                  #               #                                                        
//                                  # # # # #       # # # # #                                                
//                                          #               #                                                
//                                      # # #   # # #   # # #                                                
//                                      #       #   #   #                                                    
//                                      # # #   #   # # #                                                    
//                                          #   #                                                            
//                                          # # #  

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': FF+F-F-FF-F-F-fFF
// Rewriting rule for 'f': f
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F
// Rewrite 1: FF+F-F-FF-F-F-fFF
//      #    
//      #    
//      #    
//      #    
//  # # # # #
//  #       #
//  # # # # #
//      #    
//      #    
//      #    
//      #    

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': FF+F-F-FF-F-F-fFF
// Rewriting rule for 'f': fffff
// Number of times to apply the rewriting rules: 2
// Rewrite 0: F
// Rewrite 1: FF+F-F-FF-F-F-fFF
// Rewrite 2: FF+F-F-FF-F-F-fFFFF+F-F-FF-F-F-fFF+FF+F-F-FF-F-F-fFF-FF+F-F-FF-F-F-fFF-FF+F-F-FF-F-F-fFFFF+F-F-FF-F-F-fFF-FF+F-F-FF-F-F-fFF-FF+F-F-FF-F-F-fFF-fffffFF+F-F-FF-F-F-fFFFF+F-F-FF-F-F-fFF
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                      # # # # #                    
//                      #       #                    
//                      # # # # #                    
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                      # # # # #                    
//                      #       #                    
//                      # # # # #                    
//                          #                        
//              # # #       #       # # #            
//              #   #       #       #   #            
//      # # # # #   # # # # # # # # #   # # # # #    
//      #       #   #               #   #       #    
//      #       # # #               # # #       #    
//      #                                       #    
//  # # # # #                               # # # # #
//  #       #                               #       #
//  # # # # #                               # # # # #
//      #                                       #    
//      #       # # #               # # #       #    
//      #       #   #               #   #       #    
//      # # # # #   # # # # # # # # #   # # # # #    
//              #   #       #       #   #            
//              # # #       #       # # #            
//                          #                        
//                      # # # # #                    
//                      #       #                    
//                      # # # # #                    
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                          #                        
//                      # # # # #                    
//                      #       #                    
//                      # # # # #                    
//                          #                        
//                          #                        
//                          #                        
//                          #    

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
// Rewriting rule for 'f': f    
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F
// Rewrite 1: F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
//          #        
//          #        
//          #   # # #
//          #   #   #
//          #   #   #
//          #   #   #
//  # # #   #   # # #
//  #   #   #        
//  #   #   #        
//  #   #   #        
//  # # #   #        
//          #        
//          #      

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F
// Rewriting rule for 'F': F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
// Rewriting rule for 'f': ffffff
// Number of times to apply the rewriting rules: 2
// Rewrite 0: F
// Rewrite 1: F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
// Rewrite 2: F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF+ffffff-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF+F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF+F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF+F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFffffff+F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-ffffff+F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFffffff-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFFF+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
//                                                          #                                                        
//                                                          #                                                        
//                                                          #   # # #                                                
//                                                          #   #   #                                                
//                                                          #   #   #                                                
//                                                          #   #   #                                                
//                                                  # # #   #   # # #                                                
//                                                  #   #   #                                                        
//                                                  #   #   #                           # # # # #                    
//                                                  #   #   #                           #       #                    
//                                                  # # #   #                           # # # # #                    
//                                                          #                                                        
//                                                          #                       # # # # # # # # # # # # #        
//                                                          #                       #                       #        
//                                                          #   # # #               #   # # #   # # # # #   #   # # #
//                                                          #   #   #               #   #   #   #       #   #   #   #
//                                                          #   #   #               #   #   #   # # # # #   #   #   #
//                                                          #   #   #               #   #   #               #   #   #
//                                                  # # #   #   # # #       # # #   #   # # #       # # #   #   # # #
//                                                  #   #   #               #   #   #               #   #   #        
//                                                  #   #   #               #   #   #               #   #   #        
//                                                  #   #   #               #   #   #               #   #   #        
//                                                  # # #   #               # # #   #               # # #   #        
//                                                          #                       #                       #        
//                                                          #                       #                       #        
//                                                          #                       #                       #        
//                                                          #   # # #               #   # # #               #   # # #
//                                                          #   #   #               #   #   #               #   #   #
//                                                          #   #   #               #   #   #               #   #   #
//                                                          #   #   #               #   #   #               #   #   #
//                                                  # # #   #   # # #       # # #   #   # # #       # # #   #   # # #
//                                                  #   #   #               #   #   #               #   #   #        
//              # # # # #                           #   #   #               #   #   #   # # # # #   #   #   #        
//              #       #                           #   #   #               #   #   #   #       #   #   #   #        
//              # # # # #                           # # #   #               # # #   #   # # # # #   # # #   #        
//                                                          #                       #                       #        
//          # # # # # # # # # # # # #                       #                       # # # # # # # # # # # # #        
//          #                       #                       #                                                        
//          #   # # #   # # # # #   #   # # #               #   # # #                           # # # # #            
//          #   #   #   #       #   #   #   #               #   #   #                           #       #            
//          #   #   #   # # # # #   #   #   #               #   #   #                           # # # # #            
//          #   #   #               #   #   #               #   #   #                                                
//  # # #   #   # # #       # # #   #   # # #       # # #   #   # # #                                                
//  #   #   #               #   #   #               #   #   #                                                        
//  #   #   #               #   #   #               #   #   #                                                        
//  #   #   #               #   #   #               #   #   #                                                        
//  # # #   #               # # #   #               # # #   #                                                        
//          #                       #                       #                                                        
//          #                       #                       #                                                        
//          #                       #                       #                                                        
//          #   # # #               #   # # #               #   # # #                                                
//          #   #   #               #   #   #               #   #   #                                                
//          #   #   #               #   #   #               #   #   #                                                
//          #   #   #               #   #   #               #   #   #                                                
//  # # #   #   # # #       # # #   #   # # #       # # #   #   # # #                                                
//  #   #   #               #   #   #               #   #   #                                                        
//  #   #   #   # # # # #   #   #   #               #   #   #                                                        
//  #   #   #   #       #   #   #   #               #   #   #                                                        
//  # # #   #   # # # # #   # # #   #               # # #   #                                                        
//          #                       #                       #                                                        
//          # # # # # # # # # # # # #                       #                                                        
//                                                          #                                                        
//                      # # # # #                           #   # # #                                                
//                      #       #                           #   #   #                                                
//                      # # # # #                           #   #   #                                                
//                                                          #   #   #                                                
//                                                  # # #   #   # # #                                                
//                                                  #   #   #                                                        
//                                                  #   #   #                                                        
//                                                  #   #   #                                                        
//                                                  # # #   #                                                        
//                                                          #                                                        
//                                                          #                                                        

// $ ./fractal_turtle
// Initial characters (F, f, -, +): F-F-F-F
// Rewriting rule for 'F': F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
// Rewriting rule for 'f': ffffff
// Number of times to apply the rewriting rules: 1
// Rewrite 0: F-F-F-F
// Rewrite 1: F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF-F+f-FF+F+FF+Ff+FF-f+FF-F-FF-Ff-FFF
//              # # # # #                    
//              #       #                    
//              # # # # #                    
//                                           
//          # # # # # # # # # # # # #        
//          #                       #        
//          #   # # #   # # # # #   #   # # #
//          #   #   #   #       #   #   #   #
//          #   #   #   # # # # #   #   #   #
//          #   #   #               #   #   #
//  # # #   #   # # #       # # #   #   # # #
//  #   #   #               #   #   #        
//  #   #   #   # # # # #   #   #   #        
//  #   #   #   #       #   #   #   #        
//  # # #   #   # # # # #   # # #   #        
//          #                       #        
//          # # # # # # # # # # # # #        
//                                           
//                      # # # # #            
//                      #       #            
//                      # # # # #            

#include <stdio.h>
#include <string.h>

#define FALSE 0
#define TRUE 1

#define MAX_LENGTH 16384

#define CHAR_MOVE_FORWARD_PAINT 'F'
#define CHAR_MOVE_FORWARD_NOPAINT 'f'
#define CHAR_TURN_LEFT '+'
#define CHAR_TURN_RIGHT '-'

#define TILE_PAINTED " #"
#define TILE_BLANK "  "

#define DOES_NOT_PAINT -1

////////////////////////////////////////////////////////////////////////////////
// Structs
////////////////////////////////////////////////////////////////////////////////

// Stores a position (row, col) pair. Used for location.
struct position {
    int row;
    int col;
};

// Stores a vector (x, y) pair. Used for direction.
struct vector {
    int x;
    int y;
};

// Object to represent a turtle by their position and direction
struct turtle {
    struct position position;
    struct vector direction;
};

// Object to represent a canvas over which a turtle walks/paints 
struct canvas {
    int is_minmax_initialised;
    struct position min;
    struct position max;
    int height;
    int width;
};


////////////////////////////////////////////////////////////////////////////////
// Function Prototypes
////////////////////////////////////////////////////////////////////////////////

void rewrite_string_n_times(
    char source[MAX_LENGTH],
    char dest[MAX_LENGTH],
    char letter_1, char rule_1[MAX_LENGTH],
    char letter_2, char rule_2[MAX_LENGTH],
    int n
);
void rewrite_string(
    char source[MAX_LENGTH],
    char dest[MAX_LENGTH],
    char letter_1, char rule_1[MAX_LENGTH],
    char letter_2, char rule_2[MAX_LENGTH]
);
void draw_turtle_interpretation_of_string(char string[MAX_LENGTH]);
struct turtle new_turtle(void);
struct canvas update_canvas_minmax(struct canvas canvas, struct turtle turtle);
struct turtle move_turtle_n_steps(struct turtle turtle, int n);
struct turtle turn_turtle_left(struct turtle turtle);
struct turtle turn_turtle_right(struct turtle turtle);
int turtle_paints_point(char string[MAX_LENGTH], int row, int col);


////////////////////////////////////////////////////////////////////////////////
// Main Function
////////////////////////////////////////////////////////////////////////////////

// Reads inputs, rewrites a string, then draws its turtle interpretation.
int main(void) {
    printf("Initial characters (F, f, -, +): ");
    char initial_string[MAX_LENGTH];
    fgets(initial_string, MAX_LENGTH, stdin);
    initial_string[strlen(initial_string) - 1] = '\0';

    printf("Rewriting rule for '%c': ", CHAR_MOVE_FORWARD_PAINT);
    char rule_1[MAX_LENGTH];
    fgets(rule_1, MAX_LENGTH, stdin);
    rule_1[strlen(rule_1) - 1] = '\0';

    printf("Rewriting rule for '%c': ", CHAR_MOVE_FORWARD_NOPAINT);
    char rule_2[MAX_LENGTH];
    fgets(rule_2, MAX_LENGTH, stdin);
    rule_2[strlen(rule_2) - 1] = '\0';

    printf("Number of times to apply the rewriting rules: ");
    int n = 0;
    scanf("%d", &n);

    char final_string[MAX_LENGTH];
    rewrite_string_n_times(
        initial_string,
        final_string,
        CHAR_MOVE_FORWARD_PAINT, rule_1,
        CHAR_MOVE_FORWARD_NOPAINT, rule_2,
        n
    );

    draw_turtle_interpretation_of_string(final_string);

    return 0;
}


////////////////////////////////////////////////////////////////////////////////
// Fuction Definitions
////////////////////////////////////////////////////////////////////////////////

// Rewrites the 'source' string 'n' times by repeatedly replacing each instance
// of char 'letter_X' with string 'rule_X', leaving the result in 'dest'.
//
// Note: this function overwrites the original 'source' string.
void rewrite_string_n_times(
    char source[MAX_LENGTH],
    char dest[MAX_LENGTH],
    char letter_1, char rule_1[MAX_LENGTH],
    char letter_2, char rule_2[MAX_LENGTH],
    int n
) {
    printf("Rewrite 0: %s\n", source);

    int count = 0;
    while (count < n) {
        if (count % 2 == 0) {
            rewrite_string(source, dest, letter_1, rule_1, letter_2, rule_2);
            printf("Rewrite %d: %s\n", count + 1, dest);
        } else {
            rewrite_string(dest, source, letter_1, rule_1, letter_2, rule_2);
            printf("Rewrite %d: %s\n", count + 1, source);
        }
        count++;
    }

    if (n % 2 == 0) {
        strncpy(dest, source, MAX_LENGTH);
    }
}


// Rewrites a string once by copying every character of 'source' into 'dest',
// replacing each occurrence of character 'letter_X' with string 'rule_X'.
void rewrite_string(
    char source[MAX_LENGTH],
    char dest[MAX_LENGTH],
    char letter_1, char rule_1[MAX_LENGTH],
    char letter_2, char rule_2[MAX_LENGTH]
) {
    int rule_1_length = strlen(rule_1);
    int rule_2_length = strlen(rule_2);

    int j = 0;
    char c;
    for (int i = 0; (c = source[i]) != '\0'; i++) {
        if (c == letter_1) {
            if (j + rule_1_length >= MAX_LENGTH) {
                printf("Warning: string exceeds maximum allowable length\n");
                return;
            }
            strcpy(dest + j, rule_1);
            j += rule_1_length;
        } else if (c == letter_2) {
            if (j + rule_2_length >= MAX_LENGTH) {
                printf("Warning: string exceeds maximum allowable length\n");
                return;
            }
            strcpy(dest + j, rule_2);
            j += rule_2_length;
        } else {
            dest[j] = c;
            j++;
        } 
    }

    dest[j] = '\0';
}


// Given a 'string', draw the turtle interpretation.
//
// The turtle interpretation is as follows:
//  - Initially, the turtle faces up towards the top of screen
//  - An 'F' means "move forwards 2 tiles, painting a line segment"
//  - An 'f' means "move forwards 2 tiles, without painting anything"
//  - A '+' means "turn left 90 degrees"
//  - A '-' means "turn right 90 degrees"
//  - Any other character in the 'string' is simply ignored/skipped
void draw_turtle_interpretation_of_string(char string[MAX_LENGTH]) {
    // initialise turtle and canvas
    struct turtle turtle = new_turtle();
    struct canvas canvas;
    canvas.is_minmax_initialised = FALSE;

    // walk through the turtle's path to find the required canvas size
    int i = 0;
    char c;
    while ((c = string[i]) != '\0') {
        if (c == CHAR_MOVE_FORWARD_PAINT) {
            canvas = update_canvas_minmax(canvas, turtle);
            turtle = move_turtle_n_steps(turtle, 1);
            canvas = update_canvas_minmax(canvas, turtle);
            turtle = move_turtle_n_steps(turtle, 1);
            canvas = update_canvas_minmax(canvas, turtle);
        } else if (c == CHAR_MOVE_FORWARD_NOPAINT) {
            turtle = move_turtle_n_steps(turtle, 2);
        } else if (c == CHAR_TURN_LEFT) {
            turtle = turn_turtle_left(turtle);
        } else if (c == CHAR_TURN_RIGHT) {
            turtle = turn_turtle_right(turtle);
        }

        i++;
    }

    // calculate values required to paint turtle path on the terminal
    canvas.height = canvas.max.row - canvas.min.row + 1;
    canvas.width = canvas.max.col - canvas.min.col + 1;
    int row_offset = canvas.min.row;
    int col_offset = canvas.min.col;

    // draw turtle interpretation of 'string' to the terminal, row-by-row
    for (int row = 0; row < canvas.height; row++) {
        for (int col = 0; col < canvas.width; col++) {
            // check if turtle paints the point
            int turtle_paint = turtle_paints_point(
                string,
                row + row_offset,
                col + col_offset
            );
            if (turtle_paint == DOES_NOT_PAINT) {
                printf(TILE_BLANK);
            } else {
                printf(TILE_PAINTED);
            }
        }
        printf("\n");
    }
}


// Returns a new turtle:
//  - positioned at row/col (0, 0), and
//  - initially, the turtle faces up towards the top of the terminal/screen.
struct turtle new_turtle(void) {
    struct turtle turtle;
    turtle.position.row = 0;
    turtle.position.col = 0;
    turtle.direction.x = 0;
    turtle.direction.y = -1;
    return turtle;
};


// Returns a canvas with its minimum and maximum bounds expanded to enclose the
// painted path of the turtle. In other words: if the turtle paints a tile
// outside of the current bounds of the canvas, the canvas size is expanded to
// contain the turtle's path.
//
// If the bounds of the canvas have not yet been initialised, this will be done
// on the first time that this function is called.
struct canvas update_canvas_minmax(struct canvas canvas, struct turtle turtle) {
    if (canvas.is_minmax_initialised == FALSE) {
        canvas.min.row = turtle.position.row;
        canvas.min.col = turtle.position.col;
        canvas.max.row = turtle.position.row;
        canvas.max.col = turtle.position.col;
        canvas.is_minmax_initialised = TRUE;
    } else {
        if (turtle.position.row < canvas.min.row) {
            canvas.min.row = turtle.position.row;
        }
        if (turtle.position.col < canvas.min.col) {
            canvas.min.col = turtle.position.col;
        }
        if (turtle.position.row > canvas.max.row) {
            canvas.max.row = turtle.position.row;
        }
        if (turtle.position.col > canvas.max.col) {
            canvas.max.col = turtle.position.col;
        }
    }

    return canvas;
}


// Returns a turtle, moved by a number_of_steps in its current direction
struct turtle move_turtle_n_steps(struct turtle turtle, int number_of_steps) {
    turtle.position.row += (turtle.direction.y * number_of_steps);
    turtle.position.col += (turtle.direction.x * number_of_steps);
    return turtle;
}


// Returns a turtle, turned left from its original direction
struct turtle turn_turtle_left(struct turtle turtle) {
    struct vector old_direction = turtle.direction;
    turtle.direction.x = old_direction.y;
    turtle.direction.y = -old_direction.x;
    return turtle;
}


// Returns a turtle, turned right from its original direction
struct turtle turn_turtle_right(struct turtle turtle) {
    struct vector old_direction = turtle.direction;
    turtle.direction.x = -old_direction.y;
    turtle.direction.y = old_direction.x;
    return turtle;
}


// Given a string, returns TRUE if a turtle interpretation would paint the tile
// located at (row, col), otherwise DOES_NOT_PAINT (i.e. normally -1).
int turtle_paints_point(char string[MAX_LENGTH], int row, int col) {
    struct turtle turtle = new_turtle();

    int i = 0;
    char c;
    while ((c = string[i]) != '\0') {
        if (c == CHAR_MOVE_FORWARD_PAINT) {
            if (turtle.position.row == row && turtle.position.col == col) {
                return TRUE;
            }
            turtle = move_turtle_n_steps(turtle, 1);
            if (turtle.position.row == row && turtle.position.col == col) {
                return TRUE;
            }
            turtle = move_turtle_n_steps(turtle, 1);
            if (turtle.position.row == row && turtle.position.col == col) {
                return TRUE;
            }
        } else if (c == CHAR_MOVE_FORWARD_NOPAINT) {
            turtle = move_turtle_n_steps(turtle, 2);
        } else if (c == CHAR_TURN_LEFT) {
            turtle = turn_turtle_left(turtle);
        } else if (c == CHAR_TURN_RIGHT) {
            turtle = turn_turtle_right(turtle);
        }

        i++;
    }

    return DOES_NOT_PAINT;
}