Programming Fundamentals

// Program to demonstrate pointers by leveling up pokemon

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

#define MAX_NAME_LEN 50

struct pokemon {
    char name[MAX_NAME_LEN];
    int level;
};

void level_up(struct pokemon *pokeball);

int main(void) {
    struct pokemon pokeball1;
    strcpy(pokeball1.name, "charmander");
    pokeball1.level = 5;

    struct pokemon pokeball2;
    strcpy(pokeball2.name, "wartortle");
    pokeball2.level = 16;

    printf("%s is level %d.\n", pokeball1.name, pokeball1.level);
    printf("%s is level %d.\n", pokeball2.name, pokeball2.level);

    level_up(&pokeball1);
    printf("%s is now level %d!\n", pokeball1.name, pokeball1.level);

    level_up(&pokeball2);
    level_up(&pokeball2);
    level_up(&pokeball2);
    level_up(&pokeball2);
    printf("%s is now level %d!\n", pokeball2.name, pokeball2.level);
}

void level_up(struct pokemon *pokeball) {
    (pokeball->level)++;
}

#include <stdio.h>

#define SIZE 6

void array_reverse(int *array, int size);

int main(void) {
    int array[SIZE] = {1, 2, 3, 4, 5, 6};
    array_reverse(array, SIZE);
    printf("Reversed array:\n");
    for (int i = 0; i < SIZE; i++) {
        printf("%d\n", array[i]);
    }
    return 0;
}

void array_reverse(int *array, int size) {
    int start = 0;
    int end = size - 1;
    while (start < end) {
        int temp = array[start];
        array[start] = array[end];
        array[end] = temp;
        start++;
        end--;
    }
}

// Counts how many times a unique number was in an array

#include <stdio.h>

#define SIZE 6

void count_frequency(int *array, int size);

int main(void) {
    int array[SIZE] = {5, 3, 5, 3, 8, 6};
    count_frequency(array, SIZE);
    return 0;
}

void count_frequency(int *array, int size) {
    int frequency[SIZE] = {};
    int already_visited = -1;
    for (int i = 0; i < size; i++) {
        int count = 1;
        for (int j = i + 1; j < size; j++) {
            if (array[i] == array[j]) {
                count++;
                frequency[j] = already_visited;
            }
        }
        if (frequency[i] != already_visited) {
            frequency[i] = count;
        }
    }

    for (int i = 0; i < size; i++) {
        if (frequency[i] != already_visited) {
            printf("The number %d came up %d times.\n", array[i], frequency[i]);
        }
    }
}

// Creates a new list by combining words in the same position in two different lists together

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

#define MAX_STR_LEN 1024

struct node {
    char word[MAX_STR_LEN];
    struct node *next;
};

struct node *create_node(char *word);
struct node *append_node(struct node *head, char *word);
struct node *combine_words(struct node *h1, struct node *h2);
void print_list(struct node *head);
void free_list(struct node *head);

int main(void) {
    struct node *list1 = NULL;
    list1 = append_node(list1, "hello");
    list1 = append_node(list1, "world");
    list1 = append_node(list1, "cheese");

    struct node *list2 = NULL;
    list2 = append_node(list2, "world");
    list2 = append_node(list2, "hello");
    list2 = append_node(list2, "pizza");

    struct node *list3 = combine_words(list1, list2);

    print_list(list3);

    free_list(list1);
    free_list(list2);
    free_list(list3);
}

struct node *create_node(char *word) {
    struct node *new = malloc(sizeof(struct node));
    strcpy(new->word, word);
    new->next = NULL;
    return new;
}

struct node *append_node(struct node *head, char *word) {
    struct node *new = create_node(word);

    if (head == NULL) {
        return new;
    }
    struct node *curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = new;
    return head;
}

// can assume the lists will be the same length
struct node *combine_words(struct node *l1, struct node *l2) {
    struct node *head = NULL;
    while (l1 != NULL) {
        char new_word[MAX_STR_LEN];
        strcpy(new_word, l1->word);
        int i = 0;
        while (new_word[i] != '\0') {
            i++;
        }
        new_word[i] = ' ';
        i++;
        strcpy(&new_word[i], l2->word);
        head = append_node(head, new_word);
        l1 = l1->next;
        l2 = l2->next;
    }
    return head;
}

void print_list(struct node *head) {
    while (head != NULL) {
        printf("%s\n", head->word);
        head = head->next;
    }
}

void free_list(struct node *head) {
    while (head != NULL) {
        struct node *temp = head;
        head = head->next;
        free(temp);
    }
}

// Simulates a bubble tea store by taking orders and printing orders
// Consists of a bubble tea store that contains a list of orders
// Each order has a list of toppings

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

#define VIEW_ORDERS 'v'
#define PLACE_ORDER 'p'
#define DETAILS 'd'
#define NO_MORE_TOPPINGS 0

enum tea {
    BLACK,
    GREEN,
    MILK,
};

enum topping_type {
    PEARLS = 1,
    LYCHEE_JELLY,
    RED_BEAN,
    GRASS_JELLY,
};

struct topping {
    enum topping_type type;
    struct topping *next;
};

struct bubble_tea {
    enum tea base;
    int sugar;
    int ice;
    struct topping *toppings;
    struct bubble_tea *next;
};

struct bubble_tea_shop {
    struct bubble_tea *orders;
};

void view_orders(struct bubble_tea_shop *shop);
void place_order(struct bubble_tea_shop *shop);
void details(struct bubble_tea_shop *shop);
void free_shop(struct bubble_tea_shop *shop);
void free_toppings(struct topping *topping);
void print_bubble_tea(struct bubble_tea *bt, int position);
void command_loop(struct bubble_tea_shop *shop);

int main(void) {
    printf("Welcome to the Bubble Tea Shop!\n");
    struct bubble_tea_shop *shop = malloc(sizeof(struct bubble_tea_shop));
    shop->orders = NULL;

    command_loop(shop);

    printf("Thanks for visiting!\n");
    free_shop(shop);

    return 0;
}

// Loops until CTRL + D, taking in commands:
// 'v': prints the tea bases of all bubble teas ordered so far
// 'p': appends a new bubble tea order to the end of the list of orders
// 'd': gets the details of a specific order (sugar, ice and toppings)
void command_loop(struct bubble_tea_shop *shop) {
    printf("\nWhat would you like to do?\n");
    printf("v: view orders\np: place an order\nd: get the details of an order\n\n");
    char command;
    while (scanf(" %c", &command) == 1) {
        if (command == VIEW_ORDERS) {
            view_orders(shop);
        } else if (command == PLACE_ORDER) {
            place_order(shop);
        } else if (command == DETAILS) {
            details(shop);
        }
        printf("\nWhat would you like to do?\n");
        printf("v: view orders\np: place an order\nd: get the details of an order\n\n");
    }
}

// Prints the tea base of all orders in the shop, with their position indexed from 1
void view_orders(struct bubble_tea_shop *shop) {
    if (shop->orders == NULL) {
        printf("No orders!!!\n");
        return;
    }
    struct bubble_tea *curr = shop->orders;
    int i = 1;
    while (curr != NULL) {
        print_bubble_tea(curr, i);
        i++;
        curr = curr->next;
        if (curr != NULL) {
            printf("\t|\n\tv\n");
        }
    }
}

// Scans in details for a bubble tea order:
// Base
// Sugar
// Ice
// Toppings until 0 is entered
// Appends the bubble tea order to the end of the list of orders in the shop
void place_order(struct bubble_tea_shop *shop) {
    // create the bubble tea and scan in fields
    struct bubble_tea *bt = malloc(sizeof(struct bubble_tea));
    int base;
    int sugar;
    int ice;
    int topping;
    scanf("%d %d %d %d", &base, &sugar, &ice, &topping);
    bt->base = base;
    bt->sugar = sugar;
    bt->ice = ice;
    bt->toppings = NULL;
    bt->next = NULL;

    // create a list of toppings until 0 is entered
    struct topping *curr_topping = bt->toppings;
    while (topping != NO_MORE_TOPPINGS) {
        struct topping *new_topping = malloc(sizeof(struct topping));
        new_topping->type = topping;
        new_topping->next = NULL;
        if (curr_topping == NULL) {
            bt->toppings = new_topping;
            curr_topping = new_topping;
        } else {
            curr_topping->next = new_topping;
            curr_topping = curr_topping->next;
        }
        scanf(" %d", &topping);
    }

    // append new bubble tea to end of list
    struct bubble_tea *curr_bt = shop->orders;
    // empty list
    if (curr_bt == NULL) {
        shop->orders = bt;
        return;
    }
    // normal append case
    while (curr_bt->next != NULL) {
        curr_bt = curr_bt->next;
    }
    curr_bt->next = bt;
    return;
}

// Prints out the details of a specific bubble tea
// sugar, ice and all toppings
void details(struct bubble_tea_shop *shop) {
    int position;
    scanf("%d", &position);
    struct bubble_tea *curr_bt = shop->orders;
    int i = 1;
    while (i < position && curr_bt != NULL) {
        i++;
        curr_bt = curr_bt->next;
    }

    if (curr_bt == NULL) {
        printf("Invalid order number\n");
        return;
    }

    printf("Sugar: %d\nIce: %d\n", curr_bt->sugar, curr_bt->ice);

    printf("The toppings in this bubble tea are:\n");
    if (curr_bt->toppings == NULL) {
        printf("no toppings\n");
        return;
    }
    struct topping *curr_topping = curr_bt->toppings;
    while (curr_topping != NULL) {
        if (curr_topping->type == PEARLS) {
            printf("Pearls\n");
        } else if (curr_topping->type == LYCHEE_JELLY) {
            printf("Lychee Jelly\n");
        } else if (curr_topping->type == RED_BEAN) {
            printf("Red Bean\n");
        } else if (curr_topping->type == GRASS_JELLY) {
            printf("Grass Jelly\n");
        }

        curr_topping = curr_topping->next;
    }
}

// Frees all toppings, bubble teas, and the shop itself
void free_shop(struct bubble_tea_shop *shop) {
    struct bubble_tea *bt = shop->orders;
    while (bt != NULL) {
        free_toppings(bt->toppings);
        struct bubble_tea *temp = bt;
        bt = bt->next;
        free(temp);
    }
    free(shop);
}

// frees all toppings including the supplied head topping
void free_toppings(struct topping *topping) {
    while (topping != NULL) {
        struct topping *temp = topping;
        topping = topping->next;
        free(temp);
    }
}

// prints a single bubble tea's given position and base
void print_bubble_tea(struct bubble_tea *bt, int position) {
    printf("%d. ", position);
    if (bt->base == BLACK) {
        printf("Black Tea\n");
    } else if (bt->base == GREEN) {
        printf("Green Tea\n");
    } else if (bt->base == MILK) {
        printf("Milk Tea\n");
    } else {
        printf("Unknown base\n");
    }
}

// Merges 2 sorted linked lists

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

#define MAX_STR_LEN 1024

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

struct node *create_node(int value);
struct node *append_node(struct node *head, int value);
struct node *merge_lists(struct node *l1, struct node *l2);
void print_list(struct node *head);
void free_list(struct node *head);

int main(void) {
    struct node *list1 = NULL;
    list1 = append_node(list1, 0);
    list1 = append_node(list1, 5);
    list1 = append_node(list1, 40);

    struct node *list2 = NULL;
    list2 = append_node(list2, 1);
    list2 = append_node(list2, 3);
    list2 = append_node(list2, 10);
    list2 = append_node(list2, 100);

    printf("List 1:\n");
    print_list(list1);
    printf("List 2:\n");
    print_list(list2);

    struct node *list3 = merge_lists(list1, list2);

    printf("Merged List:\n");
    print_list(list3);

    free_list(list3);
}

struct node *create_node(int value) {
    struct node *new = malloc(sizeof(struct node));
    new->data = value;
    new->next = NULL;
    return new;
}

struct node *append_node(struct node *head, int value) {
    struct node *new = create_node(value);

    if (head == NULL) {
        return new;
    }
    struct node *curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }
    curr->next = new;
    return head;
}

struct node *merge_lists(struct node *l1, struct node *l2) {
    if (l1 == NULL) {
        return l2;
    }
    if (l2 == NULL) {
        return l1;
    }

    struct node *head = NULL;
    struct node *curr1 = l1;
    struct node *curr2 = l2;
    struct node *prev = NULL;
    while (curr1 != NULL && curr2 != NULL) {
        if (curr1->data <= curr2->data) {
            if (head == NULL) {
                head = curr1;
                prev = head;
            } else {
                prev->next = curr1;
                prev = curr1;
            }
            curr1 = curr1->next;
        } else {
            if (head == NULL) {
                head = curr2;
                prev = head;
            } else {
                prev->next = curr2;
                prev = curr2;
            }
            curr2 = curr2->next;
        }
    }

    if (curr1 != NULL) {
        prev->next = curr1;
    } else {
        prev->next = curr2;
    }

    return head;
}

void print_list(struct node *head) {
    while (head != NULL) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("X\n");
}

void free_list(struct node *head) {
    while (head != NULL) {
        struct node *temp = head;
        head = head->next;
        free(temp);
    }
}

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

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

struct node *reverse(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 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);
    }
    
    struct node *new_head = reverse(head);
    print_list(new_head);

    return 0;
}

// Place the list into reverse order.
// The head of the list is returned.

struct node *reverse(struct node *head) {
    if (head == NULL) {
        return NULL;
    }
    struct node *previous = NULL;
    struct node *x = head;
    while (x != NULL) {
        struct node *y = x->next;
        x->next = previous;
        previous = x;
        x = y;
    }
    return previous;
}

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

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

// Place the list into reverse order.
// The head of the list is returned.

struct node *reverse(struct node *head) {
    // lists of 0 or 1 node don't need to be changed
    if (head == NULL || head->next == NULL) {
        return head;
    }

    //reverse rest of list
    struct node *new_head = reverse(head->next);

    // head->next will be the last element in the reversed rest of list
    // append head to it
    head->next->next = head;
    head->next = NULL;

    return new_head;
}

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

#define SIZE 5

struct passenger {
    double height;
    int num_bags;
};

int main(void) {

    struct passenger my_array[SIZE];
    
    for(int i = 0; i < SIZE; i++) {
        printf("Enter height & number of bags: ");
        scanf("%lf %d", &my_array[i].height, &my_array[i].num_bags);
    }

    double filter_height;
    printf("Select height: ");
    scanf("%lf", &filter_height);

    int count = 0;
    for (int i = 0; i < SIZE; i++) {
        if (my_array[i].height >= filter_height) {
            count += my_array[i].num_bags;
        }
    }

    printf("Total of %d bags from people over %lf\n", count, filter_height);


    return 0;
}

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

#define SIZE 5

int find_totals(int arr[SIZE][SIZE], int size);

int main(void) {

    int array1[SIZE][SIZE] = {{0, 3, 2, 5, 2},
                            {2, 1, 5, 1, 1},    // == 10
                            {4, 4, 7, 7, 0},
                            {10, 0, 0, 0, 0},   // == 10
                            {0, 0, 0, 0 ,0}};

    printf("%d rows had a sum of 10\n", find_totals(array1, SIZE));

    return 0;
}

int find_totals(int arr[SIZE][SIZE], int size) {

    int count = 0;

    for (int row = 0; row < size; row++) {

        int row_total = 0;
        for (int col = 0; col < size; col++) {
            row_total += arr[row][col];
        }

        if (row_total == 10) {
            count++; 
        }
    }

    return count;
}

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

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

// Provided Functions
struct node *create_node(int data);
struct node *insert_at_head(struct node *head, int data);
void print_list(struct node *head);

// Your functions
struct node *insert_after_lowest(struct node *head, int data);

// Solution Functions
int find_lowest(struct node *head);

int main(void) {

    struct node *head = insert_at_head(NULL, 6);
    head = insert_at_head(head, 2);
    head = insert_at_head(head, 4);
    
    print_list(head);
    head = insert_after_lowest(head, 99);
    print_list(head);
    
    return 0;
}

// Mallocs a new node and returns a pointer to it
struct node *create_node(int data) {
    struct node *new_node = malloc(sizeof(struct node));
    new_node->next = NULL;
    new_node->data = data;
    return new_node;
}

// Inserts at the head of a linked list
// Returns a pointer to the new head of the list
struct node *insert_at_head(struct node *head, int data) {
    struct node *new_node = create_node(data);
    new_node->next = head;
    return new_node;
}

// Prints a linked list
void print_list(struct node *head) {
    struct node *curr = head;
    while (curr != NULL) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("X\n");
}

// Inserts a new node after the node with the 
// lowest data in the list
struct node *insert_after_lowest(struct node *head, int data) {

    // If list is empty, insert at the head
    if (head == NULL) {
        return insert_at_head(NULL, data);
    }

    int min_val = find_lowest(head);

    struct node *curr = head;
    while (curr != NULL) {
        if (curr->data == min_val) {
            struct node *new = create_node(data);
            new->next = curr->next;
            curr->next = new;
            return head;
        }
        curr = curr->next;
    }

    return head;
}

// ASSUMES LIST IS NOT NULL
int find_lowest(struct node *head) {

    struct node *curr = head;
    int min = curr->data;

    while (curr != NULL) {

        if (curr->data < min) {
            min = curr->data;
        }

        curr = curr->next;
    }

    return min;
}

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

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

// Provided Functions
struct node *create_node(int data);
void print_list(struct node *head);

// Your functions
struct node *insert_at_head(struct node *head, int data);
struct node *insert_after_lowest(struct node *head, int data);
struct node *insert_at_tail(struct node *head, int data);


int main(void) {

    struct node *head = NULL;

    int count = 0;
    int data = 0;
    while(scanf("%d", &data) == 1) {
        if (count % 2 == 0) {
            head = insert_at_head(head, data);
        } else {
            head = insert_at_tail(head, data);
        }
        count++;
    }

    print_list(head);
    
    return 0;
}

// Mallocs a new node and returns a pointer to it
struct node *create_node(int data) {
    struct node *new_node = malloc(sizeof(struct node));
    new_node->next = NULL;
    new_node->data = data;
    return new_node;
}

// Inserts at the head of a linked list
// Returns a pointer to the new head of the list
struct node *insert_at_head(struct node *head, int data) {
    struct node *new_node = create_node(data);
    new_node->next = head;
    return new_node;
}

// Inserts at the tail of the linked list
// Returns a pointer to the head of the list
struct node *insert_at_tail(struct node *head, int data) {
    struct node *new_node = create_node(data);

    if (head == NULL) {
        return new_node;
    }

    struct node *curr = head;
    while (curr->next != NULL) {
        curr = curr->next;
    }

    curr->next = new_node;

    return head;

}

// Prints a linked list
void print_list(struct node *head) {
    struct node *curr = head;
    while (curr != NULL) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("X\n");
}

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

#define SIZE 5

struct coordinate {
    int x;
    int y;
};

double e_dist(struct coordinate p0, struct coordinate p1);
void adjacent_distances(struct coordinate arr[SIZE], int size);

int main(void) {

    // Only your function is called during testing
    // Any changes in this main function will not
    // be used in testing

    struct coordinate array1[SIZE] = {{.x = 1, .y = 1},
                                        {.x = 2, .y = 2},
                                        {.x = 9, .y = 2},
                                        {.x = 2, .y = 9},
                                        {.x = 0, .y = 0}};

    adjacent_distances(array1, SIZE);

    return 0;
}

void adjacent_distances(struct coordinate arr[SIZE], int size) {
    for (int i = 0; i < (size - 1); i++) {
        printf("Dist: %lf\n", e_dist(arr[i], arr[i+1]));
    }    
}

double e_dist(struct coordinate p0, struct coordinate p1) {

    return sqrt((p1.x - p0.x)*(p1.x - p0.x)*1.0 +  (p1.y - p0.y)*(p1.y - p0.y)*1.0);
}

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

#define SIZE 5

void print_array(int arr[SIZE][SIZE], int size);
void clamp_max(int arr[SIZE][SIZE], int size, int max);

int main(void) {

    int array1[SIZE][SIZE] = {{9, 3, 2, 5, 2},
                            {2, 12, 5, 1, 11},
                            {4, 4, 7, 7, 6},
                            {10, 0, 4, 15, 0},
                            {2, 9, 0, 4, 0}};

    printf("Before:\n");
    print_array(array1, SIZE);

    clamp_max(array1, SIZE, 10);

    printf("After:\n");
    print_array(array1, SIZE);

    return 0;
}

void clamp_max(int arr[SIZE][SIZE], int size, int max) {
    for (int row = 0; row < size; row++) {
        for (int col = 0; col < size; col++) {
            if (arr[row][col] > max) {
                arr[row][col] = max;
            }
        }
    }
}

void print_array(int arr[SIZE][SIZE], int size) {
    for (int row = 0; row < size; row++) {
        for (int col = 0; col < size; col++) {
            printf("%3d ", arr[row][col]);
        }
        printf("\n");
    }
}

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

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

// Provided Functions
struct node *create_node(int data);
struct node *insert_at_head(struct node *head, int data);
void print_list(struct node *head);

// Your functions
struct node *delete_negatives(struct node *head);

// Solution Functions
int find_lowest(struct node *head);

int main(void) {

    struct node *head = insert_at_head(NULL, 6);
    head = insert_at_head(head, -2);
    head = insert_at_head(head, 4);
    
    print_list(head);
    head = delete_negatives(head);
    print_list(head);
    
    return 0;
}

// Mallocs a new node and returns a pointer to it
struct node *create_node(int data) {
    struct node *new_node = malloc(sizeof(struct node));
    new_node->next = NULL;
    new_node->data = data;
    return new_node;
}

// Inserts at the head of a linked list
// Returns a pointer to the new head of the list
struct node *insert_at_head(struct node *head, int data) {
    struct node *new_node = create_node(data);
    new_node->next = head;
    return new_node;
}

// Prints a linked list
void print_list(struct node *head) {
    struct node *curr = head;
    while (curr != NULL) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("X\n");
}


struct node *delete_negatives(struct node *head) {

    if (head == NULL) {
        return NULL;
    }

    struct node *prev = NULL;
    struct node *curr = head; 

    while (curr != NULL) {

        if (curr->data < 0) {
            struct node *to_del = curr;
            
            // is it the head?
            if (prev == NULL) {
                curr = curr->next;
                head = curr;
                free(to_del);
                
            } else {
                prev->next = curr->next;
                curr = curr->next;
                free(to_del);
            }

        } else {
            prev = curr;
            curr = curr->next;
        }
    }

    return head;
}