Forem: Shin

// understanding the trinity (arrays, pointers, and memory allocation)

Shin — Tue, 25 May 2021 11:41:04 +0000

Previously, I've talked about the two types of parameter passing and introducing memory addresses, pointers, and the concept of referencing and dereferencing as a whole. However, this isn't the last time that we'll be seeing pointers. Pointers are an integral part of C programming, providing the programmer control with the variables that they create, and we'll be seeing it anywhere, including this post's topics: arrays and strings.

As a refresher, arrays are collections of objects of the same data type: ints, doubles, chars, etc. Strings on the other hand are arrays of characters. In C, there is no native string data type, so for the language to be able to distinguish that it is indeed a string and not just an array of characters, a null terminator or '\0' is added by the end.

What's interesting though is that despite the absence of a string data type, C still have a format specifier (%s) and built-in library (string.h) dedicated for strings, which I'll be talking about in this post.

With that said, let's jump in to the problem statement.

Problem

Implement a palindrome checker using various string functions in C.
Your program should be able to:

Scan for the word to be checked

Pass the word to a function called isPalindrome which returns an int to be interpreted in the main() whether the given word is a palindrome or not.

Loop indefinitely until the word ”EXIT” is used as input.

Store each palindrome in an array, then print all palindromes before exiting the program.

For this I'll be dividing the objectives into those who belong in the main and those who aren't. Quickly listing the initial variables, the only variable I need for now is just char[] string for the user input.

isPalidrome Function
Palidromes are words that reads the same backward or forward. This is the basis that I've used for my isPalindrome function. The goal was to reverse the string and store it on a different variable, then compare it to the original to see if it's the same.

There is another way to do this, which is by comparing the chars of the string from the beginning and from the end, meeting at the middle. However, the problem statement mentions that isPalindrome should be using the built-in string functions in C, so I'll be approaching using for the solution is by the definition.

As mentioned before, C has a built-in library made for strings called string.h. It contains various functions that deals with string operations such as strcpy to copy a string to a memory address and strcat to concatenate two strings. For this function, however, I'll only be using strlen to create the reverse string, and strcmp to compare the original string to its reverse.

Although it looks like the parameter of my function is the string itself, what's being passed is actually the pointer of the string. This is due to one property of arrays where calling an array without an index is the same as calling the pointer of its first element. Since the content of the array is stored sequentially in the memory, we can access all of the array just by incrementing said pointer. This is also important to point out as most string functions require the pointer that holds the string as the parameter.

int n1, n2;
int example[] = {1, 2, 3};

n1 = example[0];
n2 = *example; // Dereferencing example
printf("%d = %d", n1, n2); // 1 = 1

n1 = example[1];
n2 = *(example + 1); // Dereferencing example
printf("%d = %d", n1, n2); // 2 = 2

Going back to the function, to reverse the string, I first made a char array of len values called sReverse, where len is the length of the string obtained by strlen(string). From there, I set up a loop traversing through the original string, assigning each letter in the ((len - 1) - i)th index to the ith index of sReverse.

// String reversal
for (i = 0; i < len; i++) {
    sReverse[i] = string[len - i - 1];
}

However, this is not done yet as all I've done is make something like {'h', 'e', 'l', 'l', 'o'} instead of "hello" because of the missing null terminator at the end. This can be done by adding the following line:
sReverse[i] = '\0';

Now that I've done that, the only thing left to do is to compare the new sReverse string and the original string. If they are the same, the function returns 1 for true, and 0 otherwise. This part of the function is easily done by strcmp.

String Compare or strcmp takes two parameters and the way it works is by going through the strings character by character and comparing them by their values in the ASCII table. Here is the reference for strcmp:

The function strcmp() compares str1 and str2, then returns [a value]:

less than 0 if str1 is less than str2

equal to 0 if str1 is equal to str2

greater than 0 if str1 is greater than str2

In this case though, all that matters is whether the string is equal or not, so I'll just be checking for if the output of strcmp is 0 or not.

This is the entirety of my isPalidrome function.

int isPalindrome(char string[]) {
    int len = strlen(string);
    char sReverse[len];
    int i;

    // String reversal
    for (i = 0; i < len; i++) {
        sReverse[i] = string[len - i - 1];
    }
    // Add a null-terminator at the end of the string
    sReverse[i] = '\0'; 

    // String comparison
    if (strcmp(string, sReverse) == 0) {
        return 1;
    } else {
        return 0;
    }
}

lowercase Function
Since isPalidrome uses strcmp (and by extension, ASCII values) to compare strings, strings that have both uppercase and lowercase letters such as "Level" or "huH" are immediately considered non-palindromes since uppercase letters have lower ASCII values than its lowercase counterparts. Therefore, I first need to standardize the inputs before passing them through isPalindrome.

Unfortunately, a built-in function that does this doesn't exist. Luckily, there's a library that deals with operations on characters itself, such as changing cases, or checking what the character is, and that is ctype.h.

lowercase is a utility function that I'll be using right before I call isPalindrome and all it does is exactly what it's called, change the case of the string to lowercase. I wanted to change the string itself instead of making a lowercase copy of the string, so I decided to use the pointer of the string to traverse it then individually use tolower(*i) where i is the pointer.

void lowercase(char* string) {
    char* i; // String pointer
    for (i = string; *i != '\0'; i++) {
        *i = tolower(*i);
    }
}

I stored the address of the string in i, and incremented it by one until it reaches the null terminator. This directly applies what I had mentioned earlier that arrays have its elements stored sequentially in the memory, so by doing i++, I am able to traverse the string.

main Function
Moving on to the main function, I went ahead and used a while loop with the terminating condition set to 1 so it would ask for input indefinitely, similar to what I already had done previously. In this case, I also added an if-else statement that would break the loop when the word EXIT is entered. All I needed to do was compare the user input to "EXIT" using strcmp. This is pretty much half of the main.

The next key thing that I needed to implement is to print all of the words that were determined to be a palindrome upon termination. This immediately told me to use arrays. One major obstacle, however, is that I don't know how many words the user is going to input since the input scanning runs indefinitely, and thus a fix-sized array will not work for this.

That said, there is another way of implementing arrays so long as the initial number of elements is known by dynamically allocating the array using malloc. In this case, I can set it to an arbitrary size and resize later on when the array is full. This is how to use malloc:

data_type ptr = malloc(initialSize * sizeof(data_type));

malloc returns a pointer of the data type indicated with the space requested calculated by sizeof(data_type) times the amount of elements that I want, similar to how the pointer of the array[0] works.

Another obstacle is that considering the array is storing strings, this array essentially becomes a multidimensional dynamically allocated array, which honestly sounds complicated, but in reality is pretty digestible. This diagram should help understand what's happening.

Therefore, the array is basically a pointer pointing to a pointer that is also pointing to a string. For this, I'll be making a char pointer array first,

int arraySize = 100;
char **array = malloc(arraySize * sizeof(char*));

and then set each element of that array to a dynamically allocated string.

int stringLength = 100;
array[i] = malloc((stringLength + 1) * sizeof(char));

Now that I have set that up, the last objective is to populate that array. Using strcpy, if isPalindrome determines that the user input is a palindrome, I can call strcpy to copy the user input into the array.

while (1) {
    // Scanning for user input

    if (strcmp(string, "EXIT") != 0) {
        lowercase(string);
        if (isPalindrome(string) == 1) {
            printf("%s is a Palidrome\n", string);

            // Storing the string
            array[i] = malloc((stringLength + 1) * sizeof(char)); 
            // +1 to account for the null-terminator
            strcpy(array[i], string); 
            // Copy the user string to the string address
            i++;
        } else {
            printf("%s is not a Palidrome\n", string);
        }
    } else {
        break;
    }
}

When the terminating condition is met, all I have to do is to loop through that array then print the elements. Finally, as always when dealing with dynamic allocation, I'll free up the 2D array by looping through the strings first, and then free the array itself.

Conclusion
Admittedly, this problem was pretty difficult especially with my almost non-existent understanding of how memory allocation works, added with the confusion once you lose track of where a pointer is pointing to.

The main issue for me was setting up the 2D array using malloc, primarily, because I can't internalize what happens when I dynamically allocate things. It only started to make sense once I had started breaking down the syntax itself, looking at what each parameter does, how do they relate to pointers and what purpose does the return value serve.

On the other hand, the arrays and strings itself as a concept was tolerable for me since I already have experience with it. But overall, with some fiddling and trying things until something sticks helped me sort of work out how to use pointers, arrays, and memory allocation the way I need it. I definitely see now how powerful these concepts are when used correctly.

// pointers: the computer's fingers

Shin — Thu, 22 Apr 2021 18:00:40 +0000

In the last post, I dove into functions and how it allows us to make recursions with its syntax. Recursion is more logic-based, showcasing the human side of functions in the sense that we, the programmers, have to think in the shoes of a problem-solver.

Diving deeper into functions, let's move on to the technical side of things, the computer's perspective. There are two ways of passing parameters into functions, both of which taps into various things about variables, memory addresses, and pointers.

So let's talk about them.

The Problem

Create a program that gets three (3) largest prime numbers from x to y, x and y are given by the user.

If x is greater than y, swap x and y.

If there are no prime numbers in the given range, the program must print zero (0). If there is only one prime number, the program must print that number. If there are two prime numbers in the given range, then both prime numbers are printed.

Right off the bat, the problem seems complicated. Breaking it down into functions with specific purposes, I will need:

function that will swap x and y
function that will check if a number n is prime
function that will print the three largest primes between an interval x, y

For the variables, I declared two ints, min for x and min for y.

Preliminaries
Before heading straight to coding, I want to talk about the concepts that I will be using. In this topic, I've learned that there are two ways of passing variables to functions: 1) passing it purely by its value and 2) passing it using its reference. Passing by value is easy as it's the parameter passing type that we've been using since the beginning; it takes the value of the variable and does computations with it. On the other hand, what does passing by reference mean?

Well first, we need to know memory addresses. In C, variables are stored in free memory addresses so the more variables you store, the more addresses are going to be occupied. Conceptually, it should look like this:

Address	Value	Variable Name
000	8	x
001	10	y
...	...	...

Question: why is this relevant?

To pass by reference, we have to pass the address of the variable itself into the function instead of the value that it holds. In concept, those addresses are assigned arbitrarily and they usually look something like a hexadecimal value, so to get their value, they are stored in variables called pointers which does exactly as the name suggests: point to the address of another variable. You can do this by the following syntax:

int *p;
int var = 1;
p = &var;

In this code, pointer p is initialized using *, and then the address of var is taken using the unary operator &, which is then stored in p. The data type of the pointer should be the same as the data type of the variable you're trying to get the address of.

The & is only one of the two operators that are used when working with pointers. Obviously, the other one is *, but it has another use aside from just initialization.

x = *p;
printf("x is: %d", x);
// x is: 1
printf("%d is the same as %d", var, x);
// 1 is the same as 1

The * checks the address stored in the pointer and then takes the value of the variable in that address. Essentially what I've done in the example is take var's address using & then store it into p, then take the value of var from p using *. This is (sort of) what passing by reference is.

It's pretty complicated at first sight, but with this in mind, I can finally move on to making the program.

The Swapper Function
There are situations where using passing by reference is more preferred over passing by value (and vice versa) and it is on the hands of the programmer to decide which is more appropriate for the problem.

Passing by value is suitable in many cases and you can get by with just using it. However, since only the value is only needed, the function needs to copy it first, which can be expensive in the performance with larger variables. Aside from that, pass by value only works on the copy, so on occasions that you'd want to perform computations on the variable itself, it would be more appropriate to pass by reference.

Since I'm required to swap the values of two variables, I think it would be better to pass by reference directly. Simply enough, all the function does is take the pointers of the numbers as parameters, store the value of one address in a temporary variable, and then swap them as usual. The function will be void as well since I've already swapped the numbers and don't need to return anything else.

void swap(int *n, int *m) {
    int temp = *n;
    *n = *m;
    *m = temp;
}

The Prime Checker Function
Initially, I thought of just adding this bit to the function that prints the primes, however, it would be difficult to implement (and read) as the function is doing two different things, counterproductive for a function. In this case, I'm just checking whether the number is prime or not, so there would be no pass by reference.

As mentioned in the previous post, to find primes, all I need to do is check if the number is not divisible by at least one smaller number except 1. This version of the function is implemented with an iterative approach using a for loop starting from n - 1 down to 2. When the loop finishes with no divisor found, it returns the value of flag, a local variable set to 1 by default, indicating that it is prime. Whereas if a smaller number is found, the loop breaks, changing the value of flag to 0 and returning it.

int isPrime(int n) {
    int flag = 1;
    for (int i = n - 1; i >= 2; i--) {
        if (n % i == 0) {
            flag = 0;      // If divisor is found,
            break;         // break loop and return 0
        }
    }
    return flag;
}

The Prime Printer Function
For this function, I'll only be printing numbers, so I made the return type void. It works is by checking if the number is prime using the isPrime function, starting from the upper bound of the interval, allowing the function to print the largest primes first. It also has a local variable counter that records how many primes have been found and breaking the loop when three are found. Any less than that will be printed regardless, but if nothing is found, it will print 0.

void firstPrimes(int max, int min) {
    int primes = 0;
    for (int i = max; i >= min; i--) {
        if (isPrime(i) == 1) {
            if (primes < 3) {
                primes++;
                printf("%d ", i);
            } else {
                break;     // If there are 3 primes already,
            }              // stop printing
        }
    }
    if (primes == 0) {
        printf("0");
    }
}

The Other Parts
Lastly, the only thing left is to place the function calls wherever necessary in the main. Before that, I added an input prompt for the two numbers x and y, with x as the lower bound and y as the upper bound. Once the user has placed two numbers, the program will check if x is greater than y, calling swap. If all goes well, the program then calls firstPrimes, printing the largest three primes.

Conclusion
Overall, this has been a new experience for me. It's interesting to see how C deals with its memory management on a deeper level. Learning pointers, to me, feels like a great way to understand how the computer hardware handles the variables and calculations that we add to our programs. Admittedly, this is something that I tend to overlook with other programming languages, and I guess this topic acts like a reminder that "Hey! All this is being processed by your computer's memory." I think that is one of the greatest things about low-level languages.

// functions and recursions, a tasteful combination

Shin — Tue, 20 Apr 2021 17:26:47 +0000

With most of the basics tackled, I moved on to functions as well as another concept that comes with it and is fundamental to a lot of languages, recursion. Because of the ability of functions to contain a problem and define it using parameters, we are able to implement recursion whose whole idea is to divide the problem into simpler instances of itself. In a more practical sense, the parameterization that's brought by functions blends well with recursion, and this can be done by using simpler parameters repeatedly until it reaches a base case from which it terminates.

The way I see it, functions and recursions are the bread-and-butter of programming when we try to solve problems through the divide-and-conquer approach.

Like the last post, these concepts are mostly familiar to me but there are also bits of the syntax that are specific to C only, which I will briefly mention by the end of this post.

The Problem

Create a program that asks for an integer n and lists all prime numbers from 1 to n. Start by a creating recursive function that determines whether an integer is prime or not. Next, ask for an integer n, then loop through all the integers from 1 to n. Check each integer if it is prime by using the function earlier then print the integer if it is prime.

Looks simple enough. Breaking the problem down, there are three things that I need to do:

recursive function that checks if a number is prime
user input for a number n
loop from 1 to n that calls the function and prints the number if it's prime

For this program, I only need a single int variable n.

The Recursive Function
Starting with the hard bit of the program, I first needed to figure out how to check the number if it's prime and then express that recursively. Initially, I thought of dividing the numbers by the first four prime numbers, however, I realized that this method only works for numbers below 100. Since I need a more general description for prime numbers, I looked for its definition.

A prime number is a natural number greater than 1 that cannot be formed by multiplying two smaller natural numbers.

From this, we can infer that primes can only be expressed as a product of 1 and itself, and any number that can be divided by any smaller number means it is not a prime. Iteratively, this is easy to do since I can just make a loop dividing num from num - 1 to 2, unfortunately, this is not the case with recursion.

Luckily, recursive functions, in general, can be divided into two parts: the base case and the recursive case. The base case is essentially the predefined outcome for the simplest version of the problem, hence base, whereas the recursive case reduces the parameters of the next function call until we get to the base case. The base case is very important as it decides when should the program stop calling itself (since otherwise, the function would continue on and on).

For example, a Fibonacci sequence is a sequence where each number is the sum of the two previous ones, but since we don't know what the "two previous ones" mean, we have to define it ourselves, and that acts as the base case.
Recursive Case:
Fn = Fn - 1 + Fn - 2
Base Cases:
F1 = 1
F2 = 1

Since the function should check if a number n is divisible by numbers less than num, my function will have two parameters, int num and int div with div being the parameter that will be reduced every recursive call.

int isPrime(int num, int div);

In this problem, if the function finds a number that can divide num, it should immediately conclude that the number is not prime, however, if it haven't, it should continue looking for a smaller number by putting div - 1 as the new parameter. This will be the recursive case.

if (num % div == 0) {
    return 0; // num is not prime
} else {
    return isPrime(num, div - 1);
}

On the other hand, the logical base case would be when div is equal to 1 because that would mean that function have gone through all the numbers and found nothing that can divide num. Overall:

int isPrime(int num, int div) {
    // BASE CASE
    if (div == 1) {
        return 1; // num is prime
    // RECURSIVE CASE
    } else {
        if (num % div == 0) {
            return 0; // num is not prime
        } else {
            return isPrime(num, div - 1);
        }
    }
}

The Other Parts
For the user input, I simply added a prompt for the user then used scanf as usual, storing it in n. After that, I added the loop that will go through all the numbers from 2 to n and call the function. If the function returns 1, it should print the number.

int n;
printf("Enter a positive integer: ");
scanf("%d", &n);

printf("\nThe prime numbers from 1 to %d are: ", n);
for (int i = 2; i <= n; i++) {
    if (isPrime(i, i - 1) == 1) {
        printf("%d ", i);
    }
}

One thing that I haven't mentioned yet is that in C, the compiler issues out a warning when a function is called before it was declared. The order doesn't really matter because the program can run just fine, but it helps with efficiency and memory consumption as the program doesn't need to pass (read the code) more than once. So, either declare the function below main or add a prototype of the function on top of the code.

Conclusion
All in all, this has been a nice refresher for me about functions and recursions, and it's definitely nice to see them in the context of C. But aside from that, I had a glimpse of how the compiler works with respect to the functions declared on the program, which is new knowledge from me. With regards to recursion, obviously, it's overkill to use recursion for a simple loop as recursion tends to be costly, so for every problem that involves repetition, I believe that as a programmer, it is good practice that we use these concepts only whenever it is appropriate.

// c-ntax, c-lections, and the basics of c

Shin — Mon, 19 Apr 2021 14:18:33 +0000

I've quite an experience with programming particularly in high-level languages like Python and Javascript with the exception of Java, but learning C is something different in terms of how it works on a deeper level. Similar to Java, the program must be compiled first before you can run it. Some syntax from Java and C are also similar so there's a degree of familiarity that I am comfortable with, but there are also vastly different things as well which this post will tackle.

With that said, my journey with C have started with this problem set:

"Create a C program that will compute for the body-mass index of a given height and weight. After calculating the BMI, the program will also tell under which category (underweight, normal weight, overweight, or obese) it belongs to. The user will be given two (2) choices before entering the height and weight (those choices being metric and imperial measurements). The menu must loop repeatedly until the exit option is entered. Make sure to have proper error prompts."

Breaking the problem down, there are several things that are necessary for the program:

prompts and user input
selection for the two modes of calculating BMI (imperial and metric)
selection for the ranged categories the BMI belong to
the menu to loop indefinitely until the exit option is selected; and finally
error prompts for invalid inputs for
- options that were not listed
- weight and height being 0 and less
- string inputs

Before I started coding, I wanted to list the possible variables that I will use. Since I have a menu, I would need an int option variable to store the user's choice. I would also need the variables weight, height, and BMI for the calculations, all of which are in float.

The Prompts and Inputs
Printing and scanning for inputs are one of the building blocks of any programming language, and printing/scanning in C works slightly differently from other languages.

For C, I need to import the library before I can take inputs first, and this is done by appending #include <stdio.h> on the first line, stdio.h being the library consisting the scanner.

I've added prompts that ask the user to select between the calculating options by using printf and take the input using scanf. That said, printing and scanning in C is a lot more nuanced, for one, to be able to scan (and print) variables, I have to put the format specifier of the variable. Since I've decided to use int data type for my option variable, I should use the %d specifier with scanf (and later on printf).

So far this is what I have:

#include <stdio.h>

int main() {
    int option;
    float weight, height, BMI;

    // MENU AND USER INPUT
    printf("\nSelect Mode:\n"
           "(1) Enter in kilogram and centimeters\n"
           "(2) Enter in pounds and feet\n"
           "Choice: ");
    scanf("%d", &option);

    return 0;
}

The Selections
Next up are the selection statements. After the user selects the mode, the value is stored in option. I decided to use a switch statement for this, with case: 1 being the metric measurements and case: 2 being the imperial measurements. The formula for solving BMI changes with the mode being used, so this will be the body of my cases.
Metric System: BMI = weight / (height * height)
Imperial System: BMI = (703 * weight) / (height * height)

Aside from that, both cases will ask the user for the height and weight measurements. The only difference would be the user must provide the measurements according to the selected mode.

switch (option) {
    case 1:
        printf("\nEnter weight in kg: ");
        scanf("%f", &weight);
        printf("Enter height in cm: ");
        scanf("%f", &height);

        // BMI CALCULATION
        BMI = weight / (height * height);
        printf("\nYour BMI is: %f\n", BMI);
        break;
    case 2:
        printf("\nEnter weight in lbs: ");
        scanf("%f", &weight);
        printf("Enter height in in: ");
        scanf("%f", &height);

        // BMI CALCULATION
        BMI = (703 * weight) / (height * height);
        printf("\nYour BMI is: %f\n", BMI);
        break;
    default:
        break;
}

I also need a selection for the BMI categories. Since the conditions for the categories are ranged, using a chain of if-else statements would be the appropriate choice. Using the basic 4-tier BMI table as the basis, this is what I had:

// BMI CATEGORIES
if (BMI < 18.5) {
    printf("Your BMI category is: Underweight\n"); 
} else if (BMI >= 18.5 && BMI < 25.0) {
    printf("Your BMI category is: Normal\n"); 
} else if (BMI >= 25.0 && BMI < 30.0) {
    printf("Your BMI category is: Overweight\n"); 
} else if (BMI >= 30) {
    printf("Your BMI category is: Obese\n"); 
}

The Loops
This problem requires me to have a menu that will loop on and on until the exit option is selected. To do this, I started modifying the menu by putting it inside a while loop. I've made the loop run indefinitely by making the condition 1 which the loop reads as true. The only way this loop ends is by adding an if-else statement that breaks the loop if the option is equal 0.

while (1) {
    // MENU AND USER INPUT
    printf("\nSelect Mode:\n"
           "(1) Enter in kilogram and centimeters\n"
           "(2) Enter in pounds and feet\n"
           "(0) Exit\n"
           "Choice: ");
    scanf("%d", &option);

    if (option != 0) {
        // THE SWITCH STATEMENT COMES HERE
    } else {
        break;
    }
}

The Input Validation and Error Prompts
The last thing that I need is to add validation for the user inputs. For the menu, there are two things to address:

numerical inputs that are not listed as an option
string inputs

I started by putting what I already have in the while loop in an if-else statement that prints out an error prompt if option was less than 0 or greater than 2, preventing the user from entering numerical inputs that are explicitly not the three allowed options.

if (option < 0 || option > 2) {
    printf("Error: please enter a number from 0 to 2. \n");
} else {
    if (option != 0) {
        // THE SWITCH STATEMENT COMES HERE
    } else {
        break;
    }
}

However, I realized that this doesn't account for floating-point numbers between 0 to 2. Apparently, C programs only show warnings when there is a type mismatch and still compile and run regardless, as opposed to other programming languages. This made debugging input mismatches difficult since the program doesn't show any problems during runtime as warnings only show up before compilation.

The way input works in C is by input stream and the way I understand is when the user inputs various things like text, characters, numbers, and even the newline, the program reads everything as a single giant string that is split with spaces for every variable. This string is only cut when a period is typed.

Because of the decimal input being placed in an int data type, it results in this weird behavior where the input is split into two input streams by the decimal point. The whole number portion of the input is taken by the variable and the remainder is placed on the next variable, ultimately skipping the supposed scanf for that variable.

int x, y;

printf("Test: ");
scanf("%d", &x);
printf("Test: \n");
scanf("%d", &y);

For instance, if I enter 1.5 in the first prompt, only 1 would be accepted in x while the decimal is interpreted as garbage and placed in y, preventing the user from entering a different value.

To deal with this, I added a helper float temp variable that takes whatever input and then I typecasted it to int before storing in option to kind of remove the decimal portion of the input. Not the best workaround by any means but it works with what I know so far.

Input validation for strings works in somewhat the same way. Strings typed into the scanf are interpreted as garbage when placed in an int variable. Regardless, because of the user pressing Enter, a newline character gets added to the input stream, also preventing the user from entering a correct value. To fix this, I added the following line every time the validation condition detects that the input is invalid:

while ((getchar()) != '\n');

Essentially, the line continuously looks at the stream until a newline is found, then removing it to "clean" the stream for new input.

Conclusion
Overall, I have learned a lot about how C works in relation to what I already know. Of course, a good fraction of it is the fundamentals, like the data types, general structure of the main, selections and comparisons, operations, among many others. The one thing that stood out to me the most however is the way C handles user input. I found this to be quite difficult since it's different from what I am used to, like finding out that C programs do not detect type mismatches which was quite strange for me. And understandably, it should be as any first step to anything. I ended up poking around to see which works and which doesn't, and it definitely helped me discover things on my own.