Programming Fundamentals

// Temperature
// temperature.c
//
// This program scans temperatures for a week into an array, then
// prints out the temperatures for the week

#include <stdio.h>

#define NUM_DAYS 7

int main(void) {
    int temperature[NUM_DAYS];
    printf("Enter the temperatures for the week: ");

    // Scan temperature into array
    for (int i = 0; i < NUM_DAYS; i++) {
        scanf("%d", &temperature[i]);
    }

    // Print out temperatures for the week
    for (int i = 0; i < NUM_DAYS; i++) {
        printf("Day %d: %d degrees.\n", i + 1, temperature[i]);
    }
    return 0;
}

// Array Col Average
// array_col_average.c
//
// This program calculates the average of each column in a 2D array

#include <stdio.h>

#define MAX_SIZE 100

void array_col_average(int array[MAX_SIZE][MAX_SIZE], int num_rows, int num_cols);

int main(void) {
    int array[MAX_SIZE][MAX_SIZE] = {
        {0, 1, 9, 2}, 
        {5, 4, 6, 7}, 
        {7, 6, 3, 9},
        {3, 8, 1, 8}
    };

    printf("First array: \n");
    array_col_average(array, 4, 4);
   
    int array2[MAX_SIZE][MAX_SIZE] = {
        {0, 1, 2}, 
        {3, 4, 5}, 
        {6, 7, 8},
        {9, 8, 7}
    };

    printf("\nSecond array: \n");
    array_col_average(array2, 4, 3);
   
    return 0;
}


// Calculates the sum of each row of the array and prints it out
void array_col_average(int array[MAX_SIZE][MAX_SIZE], int num_rows, int num_cols) {
    int col = 0;
    while (col < num_cols) {
        int sum = 0;
        int row = 0;
        while (row < num_rows) {
            sum += array[row][col];
            row++;
        }
        double average = (double) sum / num_cols;
        printf("Average of col %d is %.2lf.\n", col, average);
        col++;
    }
    return;
}

// Calculate Weekly Earnings
// calculate_weekly_earnings.c
//
// This program calculates weekly earnings from a 2D array

#include <stdio.h>

#define NUM_DAYS 7

int main(void) {

    int array[NUM_DAYS];

    printf("Enter the amount of money earned in the week: ");

    // Scans weekly earnings into the array
    for (int i = 0; i < NUM_DAYS; i++) {
        scanf("%d", &array[i]);
    }

    // Loops through the array to calculate total weekly earnings
    int sum = 0;
    for (int i = 0; i < NUM_DAYS; i++) {
        sum += array[i];
    }

    // Prints the total weekly earnings
    printf("The total money earned this week was $%d.\n", sum);
   
    return 0;
}

// Races
// races.c
//
// This program calculates the fastest and slowest runners based
// on their average lap time.

#include <stdio.h>

#define MAX_SIZE 100

void find_fastest_and_slowest(double array[MAX_SIZE][MAX_SIZE], int num_rows, int num_cols);

int main(void) {
    double array[MAX_SIZE][MAX_SIZE] = {
        {11.12, 12.30, 11.54}, 
        {15.43, 15.67, 15.14}, 
        {12.95, 12.43, 13.02},
        {10.04, 10.56, 10.59},
        {13.89, 14.05, 13.73}
    };

    printf("First array: \n");
    find_fastest_and_slowest(array, 5, 3);
   
    double array2[MAX_SIZE][MAX_SIZE] = {
        {0, 1, 2}, 
        {3, 4, 5}, 
        {6, 7, 8},
        {9, 8, 7}
    };

    printf("\nSecond array: \n");
    find_fastest_and_slowest(array2, 4, 3);
   
    return 0;
}

// Finds the fastest and slowest racers based on their average lap time
void find_fastest_and_slowest(double array[MAX_SIZE][MAX_SIZE], int num_rows, int num_cols) {
    double min = 0;
    double max = 0;
    int slowest = 0;
    int fastest = 0;

    int row = 0;
    while (row < num_rows) {
        double sum = 0;
        int col = 0;
        while (col < num_cols) {
            sum += array[row][col];
            col++;
        }
        double average = sum / num_cols;
        if (row == 0) {
            min = average;
            max = average;
            slowest = 0;
            fastest = 0;
        } else {
            if (average > max) {
                max = average;
                fastest = col;
            } else if (average < min) {
                min = average;
                slowest = col;
            }
        }
        row++;
    }
    printf("Runner %d was the fastest with an average time of %.2lf.\n", fastest, min);
    printf("Runner %d was the slowest with an average time of %.2lf.\n", slowest, max);
    return;
}

// String Equality
// A sample solution.

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

int strings_equal(char *string1, char *string2);

int main(int argc, char *argv[]) {

    // Some simple assert-based tests.
    // You probably want to write some more.
    assert(strings_equal("", "") == 1);
    assert(strings_equal(" ", "") == 0);
    assert(strings_equal("", " ") == 0);
    assert(strings_equal(" ", " ") == 1);
    assert(strings_equal("\n", "\n") == 1);
    assert(strings_equal("This is 17 bytes.", "") == 0);
    assert(strings_equal("", "This is 17 bytes.") == 0);
    assert(strings_equal("This is 17 bytes.", "This is 17 bytes.") == 1);
    assert(strings_equal("Here are 18 bytes!", "This is 17 bytes.") == 0);

    printf("All tests passed.  You are awesome!\n");

    return 0;
}


// Takes two strings, and if they are the same,
// returns 1, or 0 otherwise.
int strings_equal(char *string1, char *string2) {
    int i = 0;

    // note if string2[i] == '\0', loops terminates too
    while (string1[i] == string2[i] && string1[i] != '\0') {
        i = i + 1;
    }

    // could be just return string1[i] == string2[i];

    if (string1[i] == string2[i]) {
        return 1;
    } else {
        return 0;
    }
}

// Convert a string to uppercase
// string_to_upper.c
//
// This program was written by YOUR-NAME-HERE (zXXXXXXX)
// on INSERT-DATE-HERE

#include <stdio.h>

void string_to_upper(char *buffer);
int uppercase(int c);

int main(int argc, char *argv[]) {

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_to_upper(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_to_upper(str)

    char str[] = "Seventeen...  SEVENTEEN, I SAY!";
    string_to_upper(str);
    printf("%s\n", str);

    return 0;
}

// Convert the characters in `buffer` to upper case
void string_to_upper(char *buffer) {
    int i = 0;
    while (buffer[i] != '\0') {
        buffer[i] = uppercase(buffer[i]);
        i = i + 1;
    }
}

int uppercase(int c) {
    if (c >= 'a' && c <= 'z') {
        return c - 'a' + 'A';
    } else {
        return c;
    }
}

// convert a string to lowercase
// a sample solution.

#include <stdio.h>

#define MAX_LEN 1024

void string_to_lower(char *buffer);
int lowercase(int c);

int main(void) {

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_to_lower(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_to_lower(str)

    char str[MAX_LEN] = "Seventeen...  SEVENTEEN, I SAY!";
    string_to_lower(str);
    printf("%s\n", str);

    return 0;
}

// Convert the characters in `buffer` to lower case
void string_to_lower(char *buffer) {
    int i = 0;
    while (buffer[i] != '\0') {
        buffer[i] = lowercase(buffer[i]);
        i = i + 1;
    }
}

int lowercase(int c) {
    if (c >= 'A' && c <= 'Z') {
        return c - 'A' + 'a';
    } else {
        return c;
    }
}

// Strings
// Some string practice:
//      - declaring & initialising
//      - printing
//      - scanning a string
//      - count vowels and consonants
//      - check string equality (check if 2 strings are the same)
//      - reverse a string
//      - string concatenation (adding a string to the end of another)
//      - title case conversion (every first letter in a word becomes a capital)
//      - count words (words are a series of characters surrounded by spaces)

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

#define MAX_STR_LEN 1024

void count_vowels_consonants(char *string);
int is_vowel(char letter);
void reverse_string(char *string);
void string_concatenation(char *string1, char *string2);
void title_case_conversion(char *string);
void count_words(char *string);

int main(void) {
    // MOST IMPORTANT/USEFUL:

    // Declare & Initialise a String
    char str1[MAX_STR_LEN] = "Hello, World!\n";

    // Print a string
    printf("%s", str1);

    // Scan a string from stdin
    fgets(str1, MAX_STR_LEN, stdin);
    str1[strcspn(str1, "\n")] = '\0';

    // Check if a string is the same as another
    char str2[] = "World";
    if (strcmp(str1, str2) == 0) {
        printf("%s and %s are the same.\n", str1, str2);
    } else if (strcmp(str1, str2) < 0) {
        printf("%s is before %s.\n", str1, str2);
    } else {
        printf("%s is before %s.\n", str2, str1);
    }

    // Copy a string into another
    strcpy(str2, str1);
    printf("str2 is now %s.\n", str2);

    // LESS IMPORTANT/EXTRA PROBLEM SOLVING

    // Count Vowels and Consonants
    count_vowels_consonants(str1);

    // Reverse a String
    reverse_string(str1);

    // String Concatenation
    string_concatenation(str1, "END");
    // Can just use the function strcat
    // strncat(str1, "END");
    printf("%s\n", str1);

    // Title Case Conversion
    title_case_conversion(str1);
    printf("%s\n", str1);

    // Count Words
    count_words(str1);
}

void count_vowels_consonants(char *string) {
    int vowel_count = 0;
    int consonant_count = 0;
    for (int i = 0; string[i] != '\0'; i++) {
        if (is_vowel(string[i])) {
            vowel_count++;
        } else if (isalpha(string[i])) {
            consonant_count++;
        }
    }
    printf("There are %d vowels and %d consonants.\n", vowel_count, consonant_count);
}

int is_vowel(char letter) {
    letter = tolower(letter);
    if (letter == 'a') {
        return 1;
    } else if (letter == 'e') {
        return 1;
    } else if (letter == 'i') {
        return 1;
    } else if (letter == 'o') {
        return 1;
    } else if (letter == 'u') {
        return 1;
    }
    return 0;
}

void reverse_string(char *string) {
    char reversed[MAX_STR_LEN];
    for (int i = 0, j = strlen(string) - 1; j >= 0; i++, j--) {
        reversed[i] = string[j];
    }
    reversed[strlen(string)] = '\0';
    printf("%s\n", reversed);
}

void string_concatenation(char *string1, char *string2) {
    int i = 0;
    while (string1[i] != '\0') {
        i++;
    }
    int j = 0;
    while (j < strlen(string2)) {
        string1[i] = string2[j];
        i++;
        j++;
    }
    string1[i] = '\0';
}

void title_case_conversion(char *string) {
    int prev = 1;
    for (int i = 0; string[i] != '\0'; i++) {
        if (prev) {
            string[i] = toupper(string[i]);
        }
        if (string[i] == ' ') {
            prev = 1;
        } else {
            prev = 0;
        }
    }
}

void count_words(char *string) {
    int prev = 1;
    int word_count = 0;
    for (int i = 0; string[i] != '\0'; i++) {
        if (prev && isalpha(string[i])) {
            word_count++;
        }
        if (string[i] == ' ') {
            prev = 1;
        } else {
            prev = 0;
        }
    }
    printf("There are %d words in this sentence.\n", word_count);
}

// How long is a (piece of) string?
// A sample solution.

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

int string_length(char *string);

int main(int argc, char *argv[]) {

    // Some simple assert-based tests.
    // You probably want to write some more.
    assert(string_length("") == 0);
    assert(string_length("!") == 1);
    assert(string_length("Hello, world!") == 13);
    assert(string_length("17... seventeen.\n") == 17);

    printf("All tests passed.  You are awesome!\n");

    return 0;
}

// Takes a string and finds its length, excluding the null-terminator.
int string_length(char *string) {
    int i = 0;
    while (string[i] != '\0') {
        i = i + 1;
    }
    return i;
}

// Copy a String
// A sample solution.

#include <stdio.h>

#define BUFFER_LENGTH 64

void string_copy(char *destination, char *source, int destination_size);

int main(int argc, char *argv[]) {
    // Declare a buffer.  In this case, we're declaring and using a
    // 64-byte buffer, but this could be any length you like, and in
    // our tests you will be required to handle arrays of any length.
    char buffer[BUFFER_LENGTH] = {0};

    // Copy a string into the buffer ...
    string_copy(buffer, "Seventeen bytes.\n", BUFFER_LENGTH);

    // ... and print it out.  The `%s` format code prints a string.
    printf("<%s>\n", buffer);

    return 0;
}

// Takes a string in `source`, and copies it to `destination`, which
// is `destSize` elements in size; only copies up to `destSize` bytes.
// Ensures the `destination` array is null-terminated.
void string_copy(char *destination, char *source, int destination_size) {
    int i = 0;

    // stop before last array element so we can add '\0'
    while (i < destination_size - 1 && source[i] != '\0') {
        destination[i] = source[i];
        i = i + 1;
    }
    destination[i] = '\0';
}

// gnirts a esreveR (Reverse a string)
// A sample solution.

#include <stdio.h>

void string_reverse(char *buffer);
int string_length(char *string);

int main(int argc, char *argv[]) {

    // NOTE: THIS WON'T WORK:
    // char *str = "Hello!"
    // string_reverse(str)
    //
    // str only points to a string literal, which it is not legal to change.
    // If you attempt to modify it on Linux you will get a runtime error.
    // Instead, you need to create an array to store the string in, e.g.:
    //
    // char str[] = "Hello!"
    // string_reverse(str)

    char str[] = ".'neetneves' :egassem terces A";
    string_reverse(str);
    printf("%s\n", str);
    return 0;
}

// Takes a string in `buffer`, and reverses it in-place.
void string_reverse(char *buffer) {
    int length = string_length(buffer);
    int i = 0;
    while (i < length/2) {

        // swap array elements
        char tmp = buffer[i];
        buffer[i] = buffer[length - i - 1];
        buffer[length - i - 1] = tmp;

        i = i + 1;
    }
}

// Takes a string and finds its length, excluding the null-terminator.
int string_length(char *string) {
    int i = 0;
    while (string[i] != '\0') {
        i = i + 1;
    }
    return i;
}

// Simple Regex
// Searches for words in a file that match any of the given substrings.
// Activity written by Paula
// Finished by [Student]

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

#define MAX_WORD_LEN 128
#define MAX_WORDS 10000


int read_words(char words[MAX_WORDS][MAX_WORD_LEN]);
int word_matches(char *word, char *argv[], int n_match);


int main(int argc, char *argv[]) {

    int n_match = argc - 1;

    printf("Enter list of words:\n");
    char words[MAX_WORDS][MAX_WORD_LEN];
    int n_words = read_words(words);


    int count = 0;
    for (int i = 0; i < n_words; i++) {
        if (word_matches(words[i], &argv[1], n_match)) {
            count++;
        }
    }
    printf("There were %d occurances in the input.\n", count);

    return 0;
}

int word_matches(char *word, char *argv[], int n_match) {
    for (int i = 0; i < n_match; i++) {
        if (strcmp(word, argv[i]) == 0) {
            return 1;
        }
    }
    return 0;
}


////////////////////////////////////////////
// DO NOT CHANGE THE FUNCTIONS BELOW HERE //
////////////////////////////////////////////

// removes a trailing newline from a string if it exists.
void remove_newline(char *str) {
    int len = strlen(str);
    if (str[len - 1] == '\n') {
        str[len - 1] = '\0';
    }
}

// reads words from stdin until ctrl-d (assuming 1 word per line)
// stores the words in words[][] without trailing newlines
// returns the number of words found.
int read_words(char words[MAX_WORDS][MAX_WORD_LEN]) {
    int i = 0;
    while (fgets(words[i], MAX_WORD_LEN, stdin) != NULL) {
        remove_newline(words[i]);
        i++;
    }
    return i;
}

// Simple Regex
// Searches for words in standard input that match any of the given search
// strings. Written by [Student]

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

#define MAX_WORD_LEN 128

void remove_newline(char *str);

int main(int argc, char *argv[]) {
    printf("Enter list of words:\n");

    int total = 0;

    char buf[MAX_WORD_LEN];
    while (fgets(buf, MAX_WORD_LEN, stdin) != NULL) {
        remove_newline(buf);
        for (int i = 1; i < argc; i++) {
            if (strcmp(buf, argv[i]) == 0) {
                total += 1;
            }
        }
    }
    printf("There were %d occurrence(s) in the input.\n", total);

    return 0;
}

void remove_newline(char *str) {
    int len = strlen(str) - 1;
    if (str[len] == '\n') {
        str[len] = '\0';
    }
}

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

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

int count_even(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_even(head);
    printf("%d\n", result);

    return 0;
}

// return the number of even values in a linked list
int count_even(struct node *head) {
    int num_even = 0;
    struct node *p = head;
    while (p != NULL) {
        if (p->data % 2 == 0) {
            num_even = num_even + 1;
        }
        p = p->next;
    }
    return num_even;
}

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

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

// return the number of even values in a linked list
// cute, recursive solution
int count_even(struct node *head) {
    if (head == NULL) {
        return 0;
    } else {
        return (head->data % 2) + count_even(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 <string.h>
#include <assert.h>

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


// Return the number of matches in the two lists, i.e. the number of
// values which occur at the same position in both linked lists.
int count_matches(struct node *head1, struct node *head2) {

    int count = 0;
    while (head1 != NULL&& head2 != NULL) {
        if (head1->data == head2->data) {
            count++;
        }

        head1 = head1->next;
        head2 = head2->next;

    }

    // PUT YOUR CODE HERE (change the next line!)
    return count;

}

// You should not change any of the code below.

int count_matches(struct node *head1, struct node *head2);
struct node *strings_to_list(int len, char *strings[]);

// DO NOT CHANGE THIS MAIN FUNCTION
int main(int argc, char *argv[]) {
    // create two linked lists from command line arguments
    int dash_arg = argc - 1;
    while (dash_arg > 0 && strcmp(argv[dash_arg], "-") != 0) {
        dash_arg = dash_arg - 1;
    }
    struct node *head1 = strings_to_list(dash_arg - 1, &argv[1]);
    struct node *head2 = strings_to_list(argc - dash_arg - 1, &argv[dash_arg + 1]);

    int result = count_matches(head1, head2);
    printf("%d\n", result);

    return 0;
}

// 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;
    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>
#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_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");
}