Programming Fundamentals

#include <stdio.h>

int main(void) {
    // declare & initialise an int to 42
    int num = 42;

    // declare & initialise a pointer to previously created int
    int *num_ptr = &num;

    // print details about num via itself
    printf("The number is %d\n", num);
    printf("The address of the number is %p\n", &num);

    // print details about num via the pointer
    printf("The number is %d\n", *num_ptr);
    printf("The address of the number is %p\n", num_ptr);

    return 0;
}

#include <stdio.h>

void add_five(int *num);

int main(void) {
    // declare & initialise 3 numbers
    int n1 = 10;
    int n2 = 20;
    int n3 = 30;

    // Print values before calling function
    printf("Numbers before are %d %d %d\n", n1, n2, n3);

    // Call function to add 5 to each number
    // showing that you can create the pointer or just pass the address
    int *n1_ptr = &n1;
    add_five(n1_ptr);
    add_five(&n2);
    add_five(&n3);

    // Print values after calling function
    printf("Numbers after are %d %d %d\n", n1, n2, n3);

    return 0;
}

void add_five(int *num) {
    *num = *num + 5;
}

#include <stdio.h>

#define MAX_SIZE 5

struct coordinate {
    int x;
    int y;
};

// void initialise_grid(struct coordinate points[]);
void initialise_array(struct coordinate *points);
void print_array(struct coordinate *points);
void update_array(struct coordinate *points);
void add_five(int *num);

int main(void) {
    // declare an array of struct coordinates
    struct coordinate points[MAX_SIZE];

    // initialise the array in a function
    initialise_array(points);

    // print the array
    print_array(points);

    // change the array - add 5 to all even numbers
    update_array(points);

    // print the array after updating
    print_array(points);

    return 0;
}

void initialise_array(struct coordinate *points) {
    for (int i = 0; i < MAX_SIZE; i++) {
        scanf("%d %d", &points[i].x, &points[i].y);
    }
}

void print_array(struct coordinate *points) {
    for (int i = 0; i < MAX_SIZE; i++) {
        printf("(%d %d) ", points[i].x, points[i].y);
    }
    printf("\n");
}

void update_array(struct coordinate *points) {
    for (int i = 0; i < MAX_SIZE; i++) {
        if (points[i].x % 2 == 0) {
            add_five(&points[i].x);
        }
        if (points[i].y % 2 == 0) {
            add_five(&points[i].y);
        }
    }
}

void add_five(int *num) {
    *num = *num + 5;
}

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

#define MAX_NAME_LEN 30

enum house_type {
    APARTMENT,
    SUBURBAN,
    MANSION,
};

struct house {
    char owner[MAX_NAME_LEN];
    enum house_type type;
    int garage_spots;
    int bedrooms;
};

struct house copy_house(struct house house, char *owner);
void print_details(struct house house, struct house *address);
void change_house(struct house *house, char *owner);

int main(void) {
    // create a house that belongs to bob
    struct house house1;
    strcpy(house1.owner, "bob");
    house1.type = APARTMENT;
    house1.garage_spots = 2;
    house1.bedrooms = 2;

    // Bob's house had a great design - let's copy it to create houses for other people!
    struct house house2 = copy_house(house1, "jane");
    struct house house3 = copy_house(house1, "steve");

    // Print out the details of each house
    print_details(house1, &house1);
    print_details(house2, &house2);
    print_details(house3, &house3);

    // they are the 'same house', but are all owned by different people with different addresses
    // passing variables to functions only passes copies

    // If bob gave a copy of the address of their house to jill, jill could go to their house and
    // actually change it:
    change_house(&house1, "jill");

    // print what was bob's house again:
    print_details(house1, &house1);

    return 0;
}

struct house copy_house(struct house house, char *owner) {
    strcpy(house.owner, owner);
    return house;
}

void print_details(struct house house, struct house *address) {
    printf("This house is owned by %s, has %d garage spots and %d bedrooms. It is a ",
            house.owner, house.garage_spots, house.bedrooms);

    if (house.type == APARTMENT) {
        printf("apartment.");
    } else if (house.type == SUBURBAN) {
        printf("suburban.");
    } else {
        printf("mansion.");
    }

    printf(" The address is %p.\n", address);
}

void change_house(struct house *house, char *owner) {
    strcpy(house->owner, owner);
    house->bedrooms = 5;
    house->garage_spots = 5;
}

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

int main(void) {
    // create an int array of 10 elements on the stack
    int array_stack[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // what if we don't know how big the array should be until runtime?
    // create an int array on the heap (take size from input)
    printf("How big should the array be? ");
    int array_size;
    scanf("%d", &array_size);

    int *array = malloc(sizeof(int) * array_size);

    // scan elements from user
    for (int i = 0; i < array_size; i++) {
        scanf("%d", &array[i]);
    }

    // print the elements
    for (int i = 0; i < array_size; i++) {
        printf("%d\n", array[i]);
    }

    // free the memory allocated on the heap
    // what happens if you don't free? Compile with --leak-check
    free(array);

    return 0;
}

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

int sum_nums(int length, char *argv[]);
int max_nums(int length, char *argv[]);
int min_nums(int length, char *argv[]);
int avg_nums(int length, int sum);

int main(int argc, char *argv[]) {
    // create functions to find the:
    //      - sum of all numbers
    //      - maximum of all numbers
    //      - minimum of all numbers
    //      - average of all numbers
    int sum = sum_nums(argc, argv);
    int max = max_nums(argc, argv);
    int min = min_nums(argc, argv);
    int avg = avg_nums(argc, sum);

    printf("The sum of all args is: %d\n", sum);
    printf("The maximum number is %d\n", max);
    printf("The minimum number is %d\n", min);
    printf("The average number is %d\n", avg);

    return 0;
}

int sum_nums(int length, char *argv[]) {
    int count = 0;
    for (int i = 1; i < length; i++) {
        count += atoi(argv[i]);
    }
    return count;
}

int max_nums(int length, char *argv[]) {
    int max = atoi(argv[1]);
    for (int i = 1; i < length; i++) {
        if (atoi(argv[i]) > max) {
            max = atoi(argv[i]);
        }
    }
    return max;
}

int min_nums(int length, char *argv[]) {
    int min = atoi(argv[1]);
    for (int i = 1; i < length; i++) {
        if (atoi(argv[i]) < min) {
            min = atoi(argv[i]);
        }
    }
    return min;
}

int avg_nums(int length, int sum) {
    return sum / length;
}

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

#define MAX_STR_LEN 1024

int main(int argc, char *argv[]) {
    // check for valid usage
    if (argc != 3) {
        printf("Error: Invalid usage. Usage: %s word1 word2.\n", argv[0]);
        return 1;
    }

    // create new joined_word string, copy argv[1] to it
    char joined_word[MAX_STR_LEN];
    strcpy(joined_word, argv[1]);

    // copy argv[2] to the end of joined_word
    int len = strlen(joined_word);

    for (int i = 0; argv[2][i] != '\0'; i++) {
        joined_word[len] = argv[2][i];
        len++;
    }
    joined_word[len] = '\0';

    // print joined_word
    printf("Joined word is %s.\n", joined_word);

    return 0;
}

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

struct node {
    struct node *next;
    int          data;
};

int count_consecutive(struct node *head);
struct node *array_to_list(int len, int array[]);
void print_list(struct node *head);

// DO NOT CHANGE THIS MAIN FUNCTION
#define MAX_INIT_LIST_LEN 100
int main() {
    // Need to read in a number of ints into an array
    printf("How many numbers in initial list?: ");
    int list_size = 0;
    scanf("%d", &list_size);
    int initial_elems[MAX_INIT_LIST_LEN] = {0};
    int n_read = 0;
    while (n_read < list_size && scanf("%d", &initial_elems[n_read])) {
        n_read++;
    }

    // create linked list from first set of inputs
    struct node *head = NULL;
    if (n_read > 0) {
        // list has elements
        head = array_to_list(n_read, initial_elems);
    }

    int n_consec = count_consecutive(head);
    printf("There is/are %d consecutive occurances.\n", n_consec);

    return 0;
}

// TODO: FIX THIS FUNCTION
// Counts the number of consecutive items in a list
// e.g. [2, 3, 2, 5, 4] has 3 consecutive occurances
int count_consecutive(struct node *head) {

    int n_consec = 0;

    if (head == NULL || head->next == NULL) {
        return 0;
    }

    struct node *curr = head->next;
    struct node *prev = head;
    while (curr != NULL) {
        if (prev->data - curr->data == 1 ||
            prev->data - curr->data == -1) {

            n_consec++;
        }

        prev = curr;
        curr = curr->next;
    }
    return n_consec;
}

// DO NOT CHANGE THIS FUNCTION
// create linked list from array of strings
struct node *array_to_list(int len, int array[]) {
    struct node *head = NULL;
    int i = len - 1;
    while (i >= 0) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = array[i];
        head = n;
        i -= 1;
    }
    return head;
}

// DO NOT CHANGE THIS FUNCTION
// print linked list
void print_list(struct node *head) {
    printf("[");
    struct node *n = head;
    while (n != NULL) {
        // If you're getting an error here,
        // you have returned an invalid list
        printf("%d", n->data);
        if (n->next != NULL) {
            printf(", ");
        }
        n = n->next;
    }
    printf("]\n");
}

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

struct node {
    struct node *next;
    int          data;
};

int sum(struct node *head);
struct node *strings_to_list(int len, char *strings[]);

int main(int argc, char *argv[]) {
    // create linked list from command line arguments
    struct node *head = strings_to_list(argc - 1, &argv[1]);

    int result = sum(head);
    printf("%d\n", result);

    return 0;
}

// Return sum of a linked list.
int sum(struct node *head) {
    int total = 0;
    struct node *n = head;
    while (n != NULL) {
        total = total + n->data;
        n = n->next;
    }
    return total;
}


// create linked list from array of strings
struct node *strings_to_list(int len, char *strings[]) {
    struct node *head = NULL;
    for (int i = len - 1; i >= 0; i = i - 1) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = atoi(strings[i]);
        head = n;
    }
    return head;
}

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

struct node {
    struct node *next;
    int          data;
};

// Return sum of a linked list.
int sum(struct node *head) {
    if (head == NULL) {
        return 0;
    }
    return head->data + sum(head->next);
}

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

struct node {
    struct node *next;
    int          data;
};

int count_favourite(struct node *head);
struct node *strings_to_list(int len, char *strings[]);

int main(int argc, char *argv[]) {
    // create linked list from command line arguments
    struct node *head = strings_to_list(argc - 1, &argv[1]);

    int result = count_favourite(head);
    printf("%d\n", result);

    return 0;
}

// Return the number of elements divisible by 17 in the linked list
int count_favourite(struct node *head) {
    int count = 0;
    struct node *n = head;
    while (n != NULL) {
        if (n->data % 17 == 0) {
            count = count + 1;
        }
        n = n->next;
    }
    return count;
}


// create linked list from array of strings
struct node *strings_to_list(int len, char *strings[]) {
    struct node *head = NULL;
    for (int i = len - 1; i >= 0; i = i - 1) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = atoi(strings[i]);
        head = n;
    }
    return head;
}

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

struct node {
    struct node *next;
    int          data;
};

// Return the number of elements divisible by 17 in the linked list
int count_favourite(struct node *head) {
    if (head == NULL) {
        return 0;
    }
    return (head->data % 17 == 0) + count_favourite(head->next);
}

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

struct node {
    struct node *next;
    int          data;
};

int get_nth(int n, struct node *head);
struct node *strings_to_list(int len, char *strings[]);

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s value list-elements\n", argv[0]);
        return 1;
    }

    int value = atoi(argv[1]);
    // create linked list from command line arguments
    struct node *head = strings_to_list(argc - 2, &argv[2]);

    int result = get_nth(value, head);
    printf("%d\n", result);

    return 0;
}

// Return the n-th element of linked list.
// n == 0 returns first element, n == 1, second element, ....
int get_nth(int n, struct node *head) {
    assert(n >= 0);
    struct node *p = head;
    int i = n;
    while (i > 0) {
        assert(p != NULL);
        p = p->next;
        i = i - 1;
    }
    assert(p != NULL);
    return p->data;
}


// create linked list from array of strings
struct node *strings_to_list(int len, char *strings[]) {
    struct node *head = NULL;
    for (int i = len - 1; i >= 0; i = i - 1) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = atoi(strings[i]);
        head = n;
    }
    return head;
}

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

struct node {
    struct node *next;
    int          data;
};

// Return the n-th element of linked list.
// n == 0 returns first element, n == 1, second element, ....
int get_nth(int n, struct node *head) {
    assert(head != NULL && n >= 0);
    if (n == 0) {
        return head->data;
    }
    return get_nth(n - 1, head->next);
}

// COMP1511 Array Print Pointer
// Print out the contents of an array, starting
// from index 0 and ending by printing out
// a particular element that is also being
// pointed at by a given pointer

// Marc Chee, March 2020

#include <stdio.h>

#define LENGTH 10

void array_print_pointer(int nums[LENGTH], int *last);

// This is a simple main function that you can use to test your array_print_pointer
// function.
// It will not be marked - only your array_print_pointer function will be marked.
//
// Note: the autotest does not call this main function!
// It calls your array_print_pointer function directly.
// Any changes that you make to this main function will not affect the autotests.

int main(int argc, char *argv[]){
   int nums[LENGTH] = {1,2,3,4,5,6,7,8,9,10};
   int *last = &nums[5];

   //Pass in the address of the sum and product variables
   array_print_pointer(nums, last);

   return 0;
}

// Print an array from the beginning until it reaches
// a pointer. Assumes that the pointer is aimed at one
// of the array elements.
void array_print_pointer(int nums[LENGTH], int *last) {
    int i = 0;
    int stop = 0;
    while (stop == 0 && i < LENGTH) { // printed i numbers
        printf("%d ", nums[i]);
        if (&nums[i] == last) { // last is aimed at nums[i]
            stop = 1;
        }
        i++;
    }
}

#include <stdio.h>

#define MAX_SIZE 100

/**
 * The array is split into two parts by the index passed in so 
 * the first part has indexes until the index non-inclusive and 
 * the second part has indexes including the index till the end of the array.
 * This function finds the sum of the first part and puts it into the first sum,
 * and finds the sum of the second part and puts it into the second sum.
 *
 * Takes in 
 * the array "array", 
 * the array's length "length", 
 * the index that splits the array into two parts "index", 
 * a pointer to where the value of the first part of the array's sum should be 
 * placed "first_sum" and 
 * a pointer to where the value of the second part of the array's sum should be 
 * placed "second_sum".
 *
 * Returns nothing.
 */
void split_sum(int array[], int length, int index, int *first_sum, int *second_sum) {

    // Gets the first sum of the array
    int i = 0;
    int sum = 0;
    while (i < index) {
        sum += array[i];
        i += 1;
    }
    *first_sum = sum;

    // Gets the second sum of the array
    sum = 0;
    while (i < length) {
        sum += array[i];
        i += 1;
    }
    *second_sum = sum;

    return;
}

/**
 * This is a simple main function that you can use to test your 
 * split_sum function.
 * It will not be marked - only your split_sum function will be marked.
 *
 * Note: The autotest does not call this main function!
 * It calls your split_sum function directly.
 * Any changes that you make to this main function will not affect the autotests.
 */
int main(void) {

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

    printf("Enter array values: ");
    int i = 0;
    int array[MAX_SIZE] = {0};
    while (i < length) {
        scanf("%d", &array[i]);
        i += 1;
    }

    printf("Enter index: ");
    int index;
    scanf("%d", &index);
    
    int first_sum;
    int second_sum;
    split_sum(array, length, index, &first_sum, &second_sum);

    printf("First sum: %d\n", first_sum);
    printf("Second sum: %d\n", second_sum);

    return 0;
}

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

struct node {
    struct node *next;
    int          data;
};

struct node *delete_second_last(struct node *head);
struct node *strings_to_list(int len, char *strings[]);
void print_list(struct node *head);

int main(int argc, char *argv[]) {
    // create linked list from command line arguments
    struct node *head = strings_to_list(argc - 1, &argv[1]);

    struct node *new_head = delete_second_last(head);
    print_list(new_head);

    return 0;
}

// Delete the second last node in list.
// The deleted node is freed.
// The head of the list is returned.

struct node *delete_second_last(struct node *head) {
    if (head == NULL || head->next == NULL) {
        // list is empty no node to delete
        return head;
    }
    if (head->next->next == NULL) {
        struct node *tmp = head->next;
        free(head);
        return tmp;
    }
    struct node *n = head;
    // find second last node in list
    while (n->next->next->next != NULL) {
        n = n->next;
    }
    struct node *tmp = n->next;
    n->next = n->next->next;
    free(tmp);

    return head;
}

// create linked list from array of strings
struct node *strings_to_list(int len, char *strings[]) {
    struct node *head = NULL;
    for (int i = len - 1; i >= 0; i = i - 1) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = atoi(strings[i]);
        head = n;
    }
    return head;
}

// print linked list
void print_list(struct node *head) {
    printf("[");

    for (struct node *n = head; n != NULL; n = n->next) {
        // If you're getting an error here,
        // you have returned an invalid list
        printf("%d", n->data);
        if (n->next != NULL) {
            printf(", ");
        }
    }
    printf("]\n");
}

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

struct node {
    struct node *next;
    int          data;
};

struct split_list {
    struct node *before;
    struct node *after;
};

struct split_list *split(struct node *head);
struct node *strings_to_list(int len, char *strings[]);
void print_list(struct node *head);

// DO NOT CHANGE THIS MAIN FUNCTION

int main(int argc, char *argv[]) {
    // create linked list from command line arguments
    struct node *head = strings_to_list(argc - 1, &argv[1]);

    struct split_list *list_split = split(head);
    printf("before = ");
    print_list(list_split->before);
    printf("after = ");
    print_list(list_split->after);

    return 0;
}


// Given a list with exactly one 0 in it, split
// the list into a list with everything before the 0,
// and a list with the 0 and everything after.
// Return a malloced split_list struct with each of these lists.
struct split_list *split(struct node *head) {
    struct split_list *list_split = malloc(sizeof(struct split_list));
    list_split->before = NULL;
    list_split->after = NULL;
    if (head->data == 0) {
        list_split->after = head;
        return list_split;
    } else {
        list_split->before = head;
        struct node *curr = head;

        while (curr->next != NULL) {
            if (curr->next->data == 0) {
                list_split->after = curr->next;
                curr->next = NULL;
                return list_split;
            }
            curr = curr->next;
        }
    }

    return NULL;

}


// DO NOT CHANGE THIS FUNCTION
// create linked list from array of strings
struct node *strings_to_list(int len, char *strings[]) {
    struct node *head = NULL;
    int i = len - 1;
    while (i >= 0) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = atoi(strings[i]);
        head = n;
        i -= 1;
    }   
    return head;
}

// DO NOT CHANGE THIS FUNCTION
// print linked list
void print_list(struct node *head) {
    printf("[");    
    struct node *n = head;
    while (n != NULL) {
        // If you're getting an error here,
        // you have returned an invalid list
        printf("%d", n->data);
        if (n->next != NULL) {
            printf(", ");
        }
        n = n->next;
    }
    printf("]\n");
}

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

struct node {
    struct node *next;
    int          data;
};

int get_nth_last(int n, struct node *head);
struct node *strings_to_list(int len, char *strings[]);

int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s value list-elements\n", argv[0]);
        return 1;
    }
    int value = atoi(argv[1]);
    // create linked list from command line arguments
    struct node *head = strings_to_list(argc - 2, &argv[2]);

    int result = get_nth_last(value, head);
    printf("%d\n", result);

    return 0;
}

// Return the n-th to last element of linked list.
// n == 1 returns last element, n == 2, second last element, ....
int get_nth_last(int n, struct node *head) {
    assert(n >= 0);
    struct node *p = head;
    int len = 0;
    struct node *c = head;
    while (c) {
        len++;
        c = c->next;
    }
    int i = len - n;
    while (i > 0) {
        assert(p != NULL);
        p = p->next;
        i = i - 1;
    }
    return p->data;
}


// create linked list from array of strings
struct node *strings_to_list(int len, char *strings[]) {
    struct node *head = NULL;
    for (int i = len - 1; i >= 0; i = i - 1) {
        struct node *n = malloc(sizeof(struct node));
        assert(n != NULL);
        n->next = head;
        n->data = atoi(strings[i]);
        head = n;
    }
    return head;
}

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

// Do not edit this struct. You may use it exactly as
// it is but you cannot make changes to it

// A node in a linked list
struct node {
    int data;
    struct node *next;
};

// ADD ANY FUNCTION DECLARATIONS YOU WISH TO USE HERE

// Remove any nodes in a list that are higher 
// than the node directly after them.
// Return the head of the list.
// The returned list must have no disorder in it!
struct node *remove_disorder(struct node *head) {
    int exit = 0;
    
    while (!exit) {
        struct node *prev = NULL;
        struct node *remNode = head;

        // find a node that needs to be removed
        while (remNode != NULL && remNode->next != NULL && remNode->data <= remNode->next->data) {
            prev = remNode;
            remNode = remNode->next;
        }
        // remove that node if it was found
        if (remNode != NULL && remNode->next != NULL) {
            if (prev == NULL) {
                // remNode is the first element of the list
                head = remNode->next;
            } else {
                prev->next = remNode->next;
            }
            free(remNode);
        } else {
            // there was no node to remove, which means the list
            // has no disorder
            exit = 1;
        }
    }    
    return head;
}

// These helper functions are for the main below and will
// have no effect on your remove_disorder. They do not
// need to be modified.
struct node *make_list(int a, int b, int c);
void printList(struct node *head);

// This is a main function which could be used
// to test your remove_disorder function.
// It will not be marked.
// Only your remove_disorder function will be marked.
//
// It's recommended to change the int values in this
// main to test whether your remove_disorder is working.
int main(void) {
    // test an ordered list
    struct node *ordered = make_list(1, 2, 3);
    ordered = remove_disorder(ordered);
    printList(ordered);
    
    // test removing one element out of order
    ordered = make_list(1, 3, 2);
    ordered = remove_disorder(ordered);
    printList(ordered);
    
    // test a completely disordered list
    ordered = make_list(3, 2, 1);
    ordered = remove_disorder(ordered);
    printList(ordered);

    // test with the first removal causing more disorder
    ordered = make_list(2, 3, 1);
    ordered = remove_disorder(ordered);
    printList(ordered);
        
    return 0;
}

// A simple function to make a linked list with 3 elements
// This function is purely for the main above
// You will be tested with lists that are more and less
// than 3 elements long
struct node *make_list(int a, int b, int c) {
    struct node *head = malloc(sizeof(struct node));
    struct node *n = head;
    n->data = a;
    n->next = malloc(sizeof(struct node));
    n = n->next;
    n->data = b;
    n->next = malloc(sizeof(struct node));
    n = n->next;
    n->data = c;
    n->next = NULL;
    
    return head;
}

void printList(struct node *head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}
// ADD ANY FUNCTION DEFINITIONS YOU WISH TO USE HERE