// 
// Written 23rd September 2021
// By Clarissa Tatang
//
// Program which takes in a number n and
// counts up from 0 till n if n is greater than 0 or
// counts down from 0 till n if n is less than 0.
// 

#include <stdio.h>

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

    int i = 0;
    if (n > 0) {
        while (i <= n) {
            printf("%d\n", i);
            i++;
        } 
    } 

    if (n < 0) {
        while (i >= n) {
            printf("%d\n", i);
            i--;
        }
    }

}

#include <stdio.h>

struct vector {
    int x;
    int y;
    int z;
};

int main(void) {

    //////////////// DO NOT CHANGE ANY OF THE CODE BELOW HERE //////////////////
    struct vector first_vector;
    struct vector second_vector;

    // Scans in vector values from user
    // Carefully read how these scanf's work ~ Try to understand it
    printf("Please enter the values of the first vector (x, y, z): ");
    scanf("%d %d %d", &first_vector.x, &first_vector.y, &first_vector.z);

    printf("Please enter the values of the second vector (x, y, z): ");
    scanf("%d %d %d", &second_vector.x, &second_vector.y, &second_vector.z);

    struct vector sum_vector;
    //////////////// DO NOT CHANGE ANY OF THE CODE ABOVE HERE //////////////////


    ///////////////////// ONLY WRITE CODE BELOW HERE ///////////////////////////
    // TODO: Fill in `sum_vector` by adding each component of `first_vector`
    // and `second_vector`
    sum_vector.x = first_vector.x + second_vector.x;
    sum_vector.y = first_vector.y + second_vector.y;
    sum_vector.z = first_vector.z + second_vector.z;

    ///////////////////// ONLY WRITE CODE ABOVE HERE ///////////////////////////


    printf("The resulting sum vector is:\n");
    printf("x: %d\n", sum_vector.x);
    printf("y: %d\n", sum_vector.y);
    printf("z: %d\n", sum_vector.z);
    return 0;
}

// Custom Cake
// custom_cake.c
//
// This program was written by Morgan Swaak (z5476300)
// on 15/01/24
//
// A program which prints out a layered cake.

#include <stdio.h>

int main(void) {
    printf("How many layers: ");
    int num_layers;
    scanf("%d", &num_layers);

    printf("Please enter layers: ");

    int i = 0;
    char layer;
    while (i < num_layers) {
        scanf(" %c", &layer);
        int j = 0;
        while (j < num_layers) {
            printf("%c", layer);
            j++;
        }
        printf("\n");
        i++;
    }
    return 0;
}

// Written ...

// Print a grid of coordinates

#include <stdio.h>

int main(void) {

    int size;
    printf("Enter size: ");
    scanf("%d", &size);

    int row = 0;
    while (row < size) {
        int col = 0;
        while (col < size) {
            printf("(%d, %d) ", row, col);
            col = col + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// Letters Between
// letters_between.c
//
// This program was written by Morgan Swaak (z5476300)
// on 31/01/24
//
// A program that prints the shortest length of characters 
// between two letters.

#include <stdio.h>

#define NUM_LETTERS 26
#define REVERSE NUM_LETTERS - 1
#define SEQUENTIAL 1

int main(void) {
    // get input
    printf("Please enter starting letter: ");
    char start_letter;
    scanf(" %c", &start_letter);
    printf("Please enter target letter: ");
    char target_letter;
    scanf(" %c", &target_letter);

    int distance_sequential = target_letter - start_letter;

    int distance_reverse = start_letter - target_letter;

    // make sure numbers are positive
    if (distance_sequential < 0) {
        distance_sequential += NUM_LETTERS;
    } else {
        distance_reverse += NUM_LETTERS;
    }

    // we also check capitalisation
    int offset;
    if ('a' <= start_letter && start_letter <= 'z') {
        offset = 'a';
    } else if ('A' <=  start_letter && start_letter <= 'Z') {
        offset = 'A';
    }

    int direction;
    if (distance_sequential <= distance_reverse) {
        direction = SEQUENTIAL;
    } else {
        direction = REVERSE;
    }

    // generalising so printing works for upper and lower case.
    int start = start_letter - offset;
    int target = target_letter - offset;

    // print out result
    int current = start;
    while (current != target) {
        printf("%c", current + offset);
        current = (current + direction) % NUM_LETTERS;
    }
    printf("%c\n", target + offset);
    return 0;
}

// Street Fighter
// street_fighter.c
//
// This program was written by Ibrahim Ghoneim (z5470570)
// on 14/01/2024
//
// Let's play Street Fighter!
// 3..2..1.. FIGHT!

#include <stdio.h>

#define MAX_HEALTH 50.0
#define MAX_ATTACK 10

// Provided fighter struct
struct fighter {
    int attack;
    double health;
    char attack_command;
};

int main(void) {
    printf("Welcome to Street Fighter!\n");
    ////////////////////////////////////////////////////////////////////////////
    ///////////////////////// Fighter 1 Creation ///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    struct fighter fighter1;

    printf("\nEnter Fighter 1's attack power (1-10): ");
    scanf("%d", &fighter1.attack);

    fighter1.health = MAX_HEALTH;

    printf("Enter an ascii character for Fighter 1's attack command: ");
    scanf(" %c", &fighter1.attack_command);
    ////////////////////////////////////////////////////////////////////////////
    /////////////////////////// REPEAT FOR FIGHTER 2 ///////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    struct fighter fighter2;

    printf("\nEnter Fighter 2's attack power (1-10): ");
    scanf("%d", &fighter2.attack);

    fighter2.health = MAX_HEALTH;

    printf("Enter an ascii character for Fighter 2's attack command: ");
    scanf(" %c", &fighter2.attack_command);
    ////////////////////////////////////////////////////////////////////////////
    //////////////////////////////// Fight Loop ////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    printf("\nFIGHT!\n\n");
    char action;
    while (fighter1.health > 0 && fighter2.health > 0) {
        printf("Fighter 1, press %c to attack: ", fighter1.attack_command);
        scanf(" %c", &action);
        if (action == fighter1.attack_command) {
            printf("Fighter 1 attacks!\n");
            if (fighter1.health < MAX_HEALTH/2) {
                fighter2.health -= fighter1.attack * 1.5;
            } else {
                fighter2.health -= fighter1.attack;
            }
        }
    ////////////////////////////////////////////////////////////////////////////
    /////////////////////////// REPEAT FOR FIGHTER 2 ///////////////////////////
    ////////////////////////////////////////////////////////////////////////////
        printf("Fighter 2, press %c to attack: ", fighter2.attack_command);
        scanf(" %c", &action);
        if (action == fighter2.attack_command) {
            if (fighter2.health < MAX_HEALTH/2) {
                fighter1.health -= fighter2.attack * 1.5;
            } else {
                fighter1.health -= fighter2.attack;
            }
            printf("Fighter 2 attacks!\n");
        }
        printf("\n");
        printf("Fighter 1's health: %.01lf\n", fighter1.health);
        printf("Fighter 2's health: %.01lf\n", fighter2.health);
    }

    ////////////////////////////////////////////////////////////////////////////
    ////////////////////////////// Fight Results ///////////////////////////////
    ////////////////////////////////////////////////////////////////////////////
    printf("\n");
    if (fighter1.health <= 0 && fighter2.health <= 0) {
        printf("It's a draw!\n");
    } else if (fighter1.health > 0) {
        printf("Fighter 1 wins!\n");
    } else {
        printf("Fighter 2 wins!\n");
    }
    
    printf("GAME OVER\n");
    return 0;
}

#include <stdio.h>

#define GAP 4


int main(void) {

    printf("Enter size: ");
    int size;
    scanf("%d", &size);

    int half_size = size/2;

    int row = 0;
    while (row < size) {
        int column = 0;
        while (column < size) {
            // Top left/bottom right quadrant
            if ((row <= half_size) == (column < half_size)) {
                if (row % GAP == column % GAP) {
                    printf("*");
                } else {
                    printf("-");
                }

            // bottom right/ top left quadrant
            } else {
                if (row % GAP == (size - 1 - column) % GAP) {
                    printf("*");
                } else {
                    printf("-");
                }
            }
            column = column + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// Written By Paula Tennent
// September 2022

#include <stdio.h>

int main(void) {
    printf("Enter size: ");
    int size = 0;
    scanf("%d", &size);

    int half = size / 2;

    int i = 0;
    while (i < size) {
        int j = 0;
        while (j < size) {
            // we want either y = x or y = (size - 1 - x) 
            // depending on the quadrant.
            int diff = i - j;

            // if its in the bottom left, or top right quadrant
            // we want y = (size - 1 - x)
            // otherwise keep it as y = x
            if ((i > half && j < half) || (i < half && j > half)) {
                diff = i + j - size + 1;
            }

            // diff % 4 will give us the stripes 4 characters apart!
            if (diff % 4 == 0) {
                printf("*");
            } else {
                printf("-");
            }

            j++;
        }
        printf("\n");
        i++;
    }
    return 0;
}

// ABC Grid
// abc_grid.c
//
// This program was written by Morgan Swaak (z5476300)
// on 31/01/24
//
// A program which prints out an abc grid cascading from a starting letter.

#include <stdio.h>

#define NUM_LETTERS 26

int main (void) {
    printf("How many rows: ");
    int num_rows;
    scanf("%d", &num_rows);
    printf("How many columns: ");
    int num_cols;
    scanf("%d", &num_cols);

    printf("Please choose starting letter: ");
    char start_letter;
    scanf(" %c", &start_letter);

    printf("Please enter starting coordinates: ");
    int start_row;
    int start_col;
    scanf("%d %d", &start_row, &start_col);

    int offset;
    if ('a' <= start_letter && start_letter <= 'z') {
        offset = 'a';
    } else if ('A' <=  start_letter && start_letter <= 'Z') {
        offset = 'A';
    }

    // first we need to calculate what char to print first
    // abc_index eg if 'a' = 0, 'b' = 1, 'z' = 25
    int abc_index = start_letter - offset;
    char row_start = (abc_index + start_row + start_col) % NUM_LETTERS + offset;
    
    // 2D loop will print out the abc_grid
    int i = 0;
    while (i < num_rows) {
        // creating a current variable which will be used for printing along 
        // the row
        char current = row_start;
        int j = 0;
        while (j < num_cols) {
            printf("%c", current);
            // abc_index eg if 'a' = 0, 'b' = 1, 'z' = 25
            abc_index = current - offset;
            // checks if column is before starting letter (count backwards 
            // through alphabet) or after (count forwards through alphabet)
            if (j < start_col) {
                current = (abc_index + NUM_LETTERS - 1) % NUM_LETTERS + offset;
            } else {
                current = (abc_index + 1) % NUM_LETTERS + offset;  
            }
            j++;
        }
        printf("\n");

        // increment row counter
        abc_index = row_start - offset;
        if (i < start_row) {
            row_start = (abc_index + NUM_LETTERS - 1) % NUM_LETTERS + offset;
        } else {
            row_start = (abc_index + 1) % NUM_LETTERS + offset;
        }
        i++;
    }
    return 0;
}

//spiral.c
//By Alex Rowell z5116848
//Written 20th/21st March 2017
//A program to print a spiral of stars

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


//A key part of this implementation is splitting the numbers into lines
//These are the straight lines of numbers, with the first number coming from the line before
//There are 4 cases to deal with each line based on which direction it would go when spiraling inwards
//(For the example below 'r' is for lines going right, 'd' for lines going down, 'u' for lines going up and 'l' for lines going left)
//eg.
// rrrrr
// ----d
// urr-d
// u---d
// lllld

int main(void) {
    int num;

    printf("Enter size: ");
    if (!scanf("%d", &num) || num % 2 == 0) {
        //Did not get a number or the number is even, exit
        return 1;
    }

    int row = 0;
    int col = 0;

    while (row < num) {
        col = 0;

        while (col < num) {
            if (row <= num/2 && row % 2 == 0 && col >= row - 1 && col <= num-row - 1) { //Line going to the right

                printf("*");

            } else if (row > num/2 && row % 2 == 0 && col <= row && col >= num - row - 1) { //Line going to the left

                printf("*");

            } else if (col <= num/2 && col % 2 == 0 && row >= col + 2 && row < num - col - 1) { //Line going upwards

                printf("*");

            } else if (col > num/2 && col % 2 == 0 && row <= col && row >= num - col) { //Line going downwards

                printf("*");

            } else { // Not part of any line

                printf("-");

            }

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

    return 0;
}

//decimal_spiral.c
//By Alex Rowell z5116848
//Written 20th March 2017
//A program to print a spiral of numbers, with the numbers increasing as it spirals outwards

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


//These are for the direction of the current line being printed (to be explained below)
#define DIR_NONE 0
#define DIR_LEFT 1
#define DIR_RIGHT 2
#define DIR_UP 3
#define DIR_DOWN 4


//A key part of this implementation is splitting the numbers into lines
//These are the straight lines of numbers, with the first number coming from the line before
//There are 4 cases to deal with each line based on which direction it would go when spiraling inwards
//(For the example below 'r' is for lines going right, 'd' for lines going down, 'u' for lines going up and 'l' for lines going left)
//eg.
// rrrrr
// ----d
// urr-d
// u---d
// lllld

int main(void) {
    int num;

    printf("Enter size: ");
    if (!scanf("%d", &num) || num % 2 == 0) {
        //Did not get a number or the number is even, exit
        return 1;
    }


    // These are the sizes of the original lines, the right line starts
    // longer than the others since it doesn't have another direction that takes its first number
    // The up line starts shorter than the others since every time it gets to the upwards line the line
    // gets smaller
    int original_up_size = num - 3;
    int original_down_size = num - 1;
    int original_right_size = num + 1;
    int original_left_size = num - 1;



    //Determine the total number of numbers to write (so that it can count down)
    //This is done by simulating each side
    int total_stars = 0;

    int up_size = original_up_size;
    int down_size = original_down_size;
    int right_size = original_right_size;
    int left_size = original_left_size;

    while (up_size > 0) {
        total_stars = total_stars + up_size;
        up_size = up_size - 4; //Every go of the spiral, each side shrinks by 4
    }
    while (down_size > 0) {
        total_stars = total_stars + down_size;
        down_size = down_size - 4;
    }
    while (right_size > 0) {
        total_stars = total_stars + right_size;
        right_size = right_size - 4;
    }
    while (left_size > 0) {
        total_stars = total_stars + left_size;
        left_size = left_size - 4;
    }


    int row = 0;
    int col = 0;

    while (row < num) {
        col = 0;

        while (col < num) {

            int line_num = 0; // The number of line changes in the spiral before this line

            int offset = 0; // The number along the line this position is

            int line_dir = DIR_NONE; //The direction the line's going (or none if a dash should be printed)


            if (row <= num/2 && row % 2 == 0 && col >= row - 1 && col <= num-row - 1) { //Line going to the right
                line_dir = DIR_RIGHT;
                line_num = (row / 2 * 4);

                offset = col - row + 2;

            } else if (row > num/2 && row % 2 == 0 && col <= row && col >= num - row - 1) { //Line going to the left
                line_dir = DIR_LEFT;
                line_num = ((num-row-1)/2 * 4) + 2;

                offset = row - col;

            } else if (col <= num/2 && col % 2 == 0 && row >= col + 2 && row < num - col - 1) { //Line going upwards
                line_dir = DIR_UP;
                line_num = (col / 2 * 4) + 3;

                offset = num - col - 1 - row;
            } else if (col > num/2 && col % 2 == 0 && row <= col && row >= num - col) { //Line going downwards
                line_dir = DIR_DOWN;
                line_num = ((num-col-1)/2 * 4) + 1;

                offset = row - num + col + 1;
            }

            if (line_dir != DIR_NONE) {
                // Reset the number of stars in the first line of each type
                // For calculating the number to print out
                up_size = original_up_size;
                down_size = original_down_size;
                right_size = original_right_size;
                left_size = original_left_size;

                int num_so_far = 0; //The total numbers that have been printed so far in the spiral
                int i = 0;

                while (i < line_num) {
                    // Similar to calculating total number of numbers printed in the whole spiral
                    // but in this case only go up to the current line
                    if (i % 4 == 0) { // rightwards line
                        num_so_far = num_so_far + right_size;
                        right_size = right_size - 4;
                    } else if (i % 4 == 1) { // downwards line
                        num_so_far = num_so_far + down_size;
                        down_size = down_size - 4;
                    } else if (i % 4 == 2) { // leftwards line
                        num_so_far = num_so_far + left_size;
                        left_size = left_size - 4;
                    } else { // i % 4 == 3, upwards line
                        num_so_far = num_so_far + up_size;
                        up_size = up_size - 4;
                    }

                    i = i + 1;
                }

                num_so_far = num_so_far + offset; // Include the amount printed in the current line

                int to_print = total_stars - num_so_far; // Subtract num_so_far from total_stars as
                // the spiral should be counting down as it goes inwards
                printf("%d", to_print % 10); // Only take last digit of what to print

            } else {
                printf("-"); // Not part of spiral, just print a dash
            }
            col = col + 1;
        }
        printf("\n");
        row = row + 1;
    }

    return 0;
}

// Draws a decimal spiral of size defined by the user. O(n^2)
// By Sabine Lim z5242579
// For COMP1511 Lab04

// The implementation consists of 2 parts:
// 1. Loop left to right, up to down, calling an isDigit function to
// know whether to print a digit or a dash for each coordinate
// 2. If a digit should be printed, call a getDigit function to
// calculate the digit to be printed

// The isDigit function is the same the code for the regular spiral, but
// instead of printing an asterisk it returns 1 to whatever code called it

// getDigit works by splitting the spiral into triangular quadrants
//
//   *******
// *  *****  *
// **  ***  **
// ***  *  ***
// **  ***  **
// *  *****  *
//   *******
//
// For the top quadrant, observe the following digits
//
// 6**************
// --------------*
// **0**********-*
// *-----------*-*
// *-**0******-*-*
// *-*-------*-*-*
// *-*-**6**-*-*-*
// *-*-*---*-*-*-*
// *-*-*-***-*-*-*
// *-*-*-----*-*-*
// *-*-*******-*-*
// *-*---------*-*
// *-***********-*
// *-------------*
// ***************
//
// The actual numbers at the location of these digits form a quadratic sequence
// 6  30  70  126
//  24  40  56
//    16  16
// Where the differences between the differences is 16.
// Using this, you can make a quadratic sequence for the top left corners
// of each box, and subtract the current column to find the digits for
// coordinates to the right
//
// You'll need to come up with a different quadratic equation for each quadrant
// Since there are 2 types of spiral (last digit in the centre, last digit
// off-centre, that's a total of 8 different quadratic equations
// Use the current column or current row accordingly to determine how much
// to add or subtract from the corner values

#include <stdio.h>

int abs(int i);
// Returns 0 if current coordinate is a dash, 1 for a digit
int isDigit(int size, int row, int col);
// Returns the integer at a specific coordinate on a box for a given size
int getDigit(int size, int row, int col);

int main() {
    int size = 0;
    printf("Enter size: ");
    scanf("%d", &size);
    int row = 0;
    while (row < size) {
        int col = 0;
        while (col < size) {
            if (isDigit(size, row, col) == 1) {
                if (row <= size / 2 && col < size / 2 && row == col + 1) {
                    // Special handling for box segments modified to be spirals
                    printf("%d", getDigit(size, row - 1, col - 1) % 10);
                } else {
                    printf("%d", getDigit(size, row, col) % 10);
                }
            } else {
                printf("-");
            }
            ++col;
        }
        printf("\n");
        ++row;
    }
    return 0;
}

int abs(int i) {
    if (i < 0) {
        i = -i;
    }
    return i;
}

int isDigit(int size, int row, int col) {
    // Absolute row distance from midpoint
    int rowDist = abs(row - size / 2);
    // Absolute column distance from midpoint
    int colDist = abs(col - size / 2);
    int isDigit = 0;
    if (size % 4 == 1) {
        // Type 1 spiral (digit in centre)
        if (row <= size / 2 && col < size / 2 && row == col + 1) {
            // Special handling to turn boxes into spirals
            if (rowDist % 2 == 0) {
                isDigit = 1;
            }
        } else if (colDist >= rowDist && colDist % 2 == 0) {
            isDigit = 1;
        } else if (colDist < rowDist && rowDist % 2 == 0) {
            isDigit = 1;
        }
    } else {
        // Type 2 spiral (no digit in centre)
        if (row <= size / 2 && col < size / 2 && row == col + 1) {
            // Special handling to turn boxes into spirals
            if (rowDist % 2 == 1) {
                isDigit = 1;
            }
        } else if (colDist >= rowDist && colDist % 2 == 1) {
            isDigit = 1;
        } else if (colDist < rowDist && rowDist % 2 == 1) {
            isDigit = 1;
        }
    }
    return isDigit;
}

int getDigit(int size, int row, int col) {
    // Row displacement from midpoint
    int rowDist = row - size / 2;
    // Absolute row distance from midpoint
    int absRowDist = abs(rowDist);
    // Column displacement from midpoint
    int colDist = col - size / 2;
    // Absolute column distance from midpoint
    int absColDist = abs(colDist);
    // Size of box current coordinate is on
    int subSize = 0;
    if (absRowDist >= absColDist) {
        subSize = 2 * absRowDist + 1;
    } else {
        subSize = 2 * absColDist + 1;
    }
    row = row - (size - subSize) / 2;
    col = col - (size - subSize) / 2;
    // Layer of current box. 0 is centre
    int layer = (subSize + 1) / 4;
    if (rowDist <= 0 && absRowDist >= absColDist) {
        // Top quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer + 8 * layer - col;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 2 - col;
        }
    } else if (colDist > 0 && absColDist > absRowDist) {
        // Right quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer + 4 * layer - row;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 4 * layer - row;
        }
    } else if (rowDist > 0 && absRowDist >= absColDist) {
        // Bottom quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer - 4 * layer + col;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 12 * layer + 4 + col;
        }
    } else {
        // Left quadrant
        if (subSize % 4 == 1) {
            // Type 1 boxes
            return 8 * layer * layer - 8 * layer + row;
        } else {
            // Type 2 boxes
            return 8 * layer * layer - 16 * layer + 6 + row;
        }
    }
}

// debug_factorial.c
//
// Write a C program that takes a positive integer as input, calculates the
// factorial of that number and prints it out.
//
// Sofia De Bellis, 2023

#include <stdio.h>

int main (void) {
    int num = 0;
    int factorial = 1;

    printf("Enter a number: ");
    scanf("%d", &num);

    int counter = num;

    while (counter > 0) {
        factorial *= counter;
        counter--;
    }    

    printf("The factorial of %d is %d\n", num, factorial);

    return 0;
}

// debug_square.c
//
// Write a C program that prints the outline of a square in asterisks ('*').
// The program should take a positive integer 'n' as input and print the 
// outline of a square of size 'n' by 'n'.
//
// Sofia De Bellis, 2023

#include <stdio.h>

int main (void) {
    int size = 0;
    int rows = 0;
    int cols = 0;

    printf("Enter the size of the pattern: ");
    scanf("%d", &size);

    while (rows < size) {
        cols = 0;
        while (cols < size) {
            if (rows == 0 || cols == 0 || rows == size - 1 || cols == size - 1) {
                printf("*");
            } else {
                printf(" ");
            }
            cols++;
        }
        printf("\n");
        rows++;
    }
    return 0;
}