DEV Community: David Mebo

Eliminating Duplicates: A Guide to Removing Duplicates from a Sorted Array

David Mebo — Sun, 12 Mar 2023 19:34:06 +0000

A new week, new challenges, and new algorithms to tackle and most importantly, understand. The algorithm we will be looking at, is an algorithm that allows one to delete duplicate elements from an already sorted array.
The algorithm in question is considered to be an easy one compared to the Dutch Flag Partitioning, which looked easy with the detailed explanation, but the reason for the difficulty being during whiteboard sessions (will update the entries with them soon) where you mix the pointer values in terms of greater, lesser and equality.
Anyhoo, let's get started with this one.

The Question

See leetcode question 26

Naive/Brute-force Approach

Obviously, there is a naive approach for this, and the plus side is its Space complexity is O(1).

Explanation/Thought Process

assign a variable to represent the length of the array
iterate through the array
- use another loop to iterate from the next index to the end of the array
  - if the element from the first loop matches the element of the second loop
  - delete the matching element found
  - decrement the length of the array by one (we do this to cover for the missing element or we will get errors or wrong values)
print the array (for visuals)
return the length of the array

delDups.py

#!/usr/bin/env python3
def delDups(arr):
    n = len(arr)

    for i in range(n):
        for j in range(i + 1, n - 1):
            if arr[i] == arr[j]:
                del arr[j]
                n -= 1
    return n

test_delDup.py

#!/usr/bin/env python3
from delDups import delDups

arr = [1, 2, 2, 3, 4, 4, 5]
dups = delDups(arr)
print(arr[:dups])

result:

5
[1, 2, 3, 4, 5]

Problem With This Solution

While it fulfills the Space complexity of O(1), the Time complexity is O(n^2), which is the result of using two nested loops which take O(n) time to iterate through the array and O(n) time for comparisons for each iteration. And by this Big O notation graph I got, it is terrible.

Better Approach and Optimal Solution

There is a better approach that takes O(n) time to sort the array, removes duplicates, and still maintains the same O(1) space as seen in the brute-force approach. We just need to make some modifications to the code.

Explanation/Thought Process

assign the length of the array to a variable and another (we'll call it idxOne) to represent the array index to be 1
check if the array is empty, if it is, stop the operation
if not, iterate through the array starting from the first index of the array
- if idxOne - 1 is not equal to the current index of the array
  - write the said index to an array, where the array is idxOne
  - idxOne is incremented by one
return idxOne

delDupsBetter.py

#!/usr/bin/env python3
def del_dups(arr):
    n = len(arr)
    idxOne = 1

    if not arr:
        return 0

    for i in range(1, n):
        if arr[idxOne - 1] != arr[i]:
            arr[idxOne] = arr[i]
            idxOne += 1
    return idxOne

test_delDupsBetter.py

#!/usr/bin/env python3
from delDupsBetter import del_dups

arr = [1, 2, 2, 3, 3, 3, 4, 5, 5]
dups = del_dups(arr)
print(dups)
print(arr[:dups])

result:

5
[1, 2, 3, 4, 5]

Problem With This Solution

None I could find. Plus, this is a bit cleaner than having to use nested loops.

LeetCode Solution

Unfortunately, not going to get creative with this one, reason being its unnecessary for this solution, so here it is:

leetcode_26.py

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        if not nums:
            return 0

        idxOne = 1
        for i in range(1, len(nums)):
            if nums[idxOne - 1] != nums[i]:
                nums[idxOne] = nums[i]
                idxOne += 1
        return idxOne

With that, I'll see you some time next week with more array-related questions, or maybe something new.
Remember to practice in your own free time though...

Optimizing Dutch Flag Partitioning for Unsorted Arrays

David Mebo — Tue, 07 Mar 2023 21:35:49 +0000

Sort Colors

Been a while since my last entry, been busy with life and trying to practice cracking algorithms, whiteboard, read some algorithm-based book... Its been wild. Anyways, this question was taken from a leetcode medium level exercise, and though it gave me some trouble trying to implement the needed code given, it was kinda worth it at the end.
Also, why medium level?
That is because I'm still covering arrays, and not gonna go crazy blazing through the whole algorithm materials I'm studying. My goal's to understand most of the algorithms with useful use-case in the real world (like this one), not some algo-junkie...
Anyways, let's get down to business.

The Question

See leetcode question 75

Naive/Brute-force Approach

This approach - I like to call it the Caveman Approach - will have us loop through the array with each successful sort. More in the section below (will be using this approach in future posts)

Explanation/Thought Process

a variable to represent the pivot is defined
a list is iterated from left to right
- with each iteration, elements smaller than the pivot are sorted to the left of the array via swaps
- the loop is exited
iterate through the list again, but in reverse
- with each iteration, elements larger than the pivot are moved to the right side of the array
- elements less than the pivot are not sorted (exit the loop if that is the case)
- the loop is exited

The code below looks like some medium-level problem alright:

dutch_flag.py

def dutch_flag_partition(pivot_idx, arr):
    pivot = arr[pivot_idx]

    # First pass: group elements smaller than the pivot, loop restarts with each sort
    for i in range(len(arr)):
        for j in range(i + 1, len(arr)):
            if arr[j] < pivot:
                arr[i], arr[j] = arr[j], arr[i]
                break

    # Second pas: group elements larger than the pivot, same as above loop
    for i in reversed(range(len(arr))):
        if arr[i] < pivot:
            break
        for j in reversed(range(i)):
            if arr[i] > pivot:
                arr[i], arr[j] = arr[j], arr[i]
                break

result:

[1, 0, 1, 0, 0, 2, 2]

Problem With This Solution

The Space complexity is O(1), but the time complexity is O(n^2). This is because in the first pass, while searching for elements to swap, the array starts sorting from the beginning after each successful swap.

Better Approach

There is another way to approach this problem that saves us time. This approach will have us continue searching for elements to swap after one has been done by resuming operations from the next index after a swap is carried out.

Explanation/Thought Process

two variables are initialized to represent the first and last index of the array and act as pointers
a variable is initialized to represent the pivot
the list is iterated from left to right
- from the loop, we check if the elements are less than the pivot element. If so, the element found is swapped with the pointer that represents the first index of the array, and the pointer is incremented. This goes on until all elements are swapped appropriately.
- loop exited, process moves to the next one
the list is iterated again, but in reverse
- if elements found are less than the pivot, the loop is broken out of
- else if elements found are greater than the pivot, the same process carried out on the first loop is repeated, but the elements found are swapped with the pointer that represents the last index of the array, and that is decremented instead.
- loop exited, you have your sorted list/array.

Problem With The Solution

None actually, except maybe white-boarding this might give newbies a headache for days, especially if you got the case of OCD or it's your first time, and still got OCD...
Anyways, Space complexity is O(1) like above, no additional memory created, only swaps, but Time complexity is O(n), because we are sorting the array elements in one iteration through the loop compared to the Brute-force approach.

Code below:
dutch_flag_On_improved.py

def dutch_flag_partitioning(pivot_idx, arr):
    pivot = arr[pivot_idx]
    smaller = 0
    # First pass: groups elements smaller than the pivot
    for i in range(len(arr)):
        if arr[i] < pivot:
            # swap the elements between each other
            arr[i], arr[smaller] = arr[smaller], arr[i]
            # increment smaller variable/ptr
            smaller += 1

    # Second pass: groups elements larger than the pivot
    larger = len(arr) - 1
    for i in reversed(range(len(arr))):
        if arr[i] < pivot:
            break
        elif arr[i] > pivot:
            arr[i], arr[larger] = arr[larger], arr[i]
        larger -= 1

Result:

[0, 2, 1, 0, 1, 0, 2]

Optimal Solution

This one looks like how a Dutch Flag Partitioning should look like, given the pseudocode seen on Wikipedia when Dutch Flag Partition is looked up.

Explanation/Thought Process

Three variables (we will call them smaller, equal, and larger) are created to represent the first and last indexes of the array, with two out of the three variables initialized to the beginning of the array/list. These will be the pointers
a loop is created, which executes if the equal pointer is less than the larger pointer
- if the array element is equal to zero, the smaller and equal pointers elements are swapped, and the smaller and equal pointer is incremented by one.
- else if the array element is equal to two, the equal and larger elements represented by their respective pointers are swapped, and the pointers are incremented by one.
- else, we increment the equal pointer.

Problem With The Solution

None.

Code below:
dutch_flag_On_improved2.py

def dutch_flag_partitioning2(pivot_idx, arr):
    # pivot = arr[pivot_idx]

    smaller, equal, larger = 0, 0, len(arr) - 1

    while equal < larger:
        if arr[equal] == 0:
            arr[smaller], arr[equal] = arr[equal], arr[smaller]
            smaller, equal = smaller + 1, equal + 1
        elif arr[equal] == 2:
            arr[equal], arr[larger] = arr[larger], arr[equal]
            larger -= 1
        else:
            equal += 1

Looks pretty basic for a medium-level problem, but I assure you it is not basic, especially if you are white-boarding.

My Solution

Here's my own solution. Implementing the larger part was a pain. Code below:

mine.py

class Solution:
    def sortColors(self, nums: list[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        smaller, larger = 0, len(nums) - 1

        """Iterate through the array"""
        for i in range(len(nums)):
            """If the element in the array is on the smaller side based
            on the Dutch flag algorithm, swap and increment the smaller ptr"""
            if nums[i] == 0:
                nums[i], nums[smaller] = nums[smaller], nums[i]
                smaller += 1
                """Else if the element is on the larger side, decrement if
                it is on the larger side and also if the current array element
                is less than the larger element"""
                """Also check again for elements on the smaller side and
                move accordingly"""
            elif nums[i] == 2:
                while i < larger and nums[larger] == 2:
                    larger -= 1
                nums[i], nums[larger] = nums[larger], nums[i]
                if nums[i] == 0:
                    nums[i], nums[smaller] = nums[smaller], nums[i]
                    smaller += 1

result:
An ordered list of 0's, 1's, and 2's.

Unlock the Power of Arrays: Tips and Tricks for Working with Arrays

David Mebo — Wed, 01 Mar 2023 17:15:12 +0000

It is no news that most wizards in the programming community, even accomplished polyglots do not like Python due to its weird(?) way of doing things. Still, hey, technology is all about innovation and change.

Some things to note though when working with arrays in Python:

They are called lists.
There are other types of arrays that are similar, but different from lists, like tuples, dictionaries,...
Know the syntax for instantiating a list, e.g., [1, 2, 3, 4], [1] + [2] * [3].
Know how to use the functions insert, append, and remove, and do not be afraid to use them if you cannot do the operations manually. It's all about innovation and using the libraries and functions already provided instead of trying to reinvent the wheel, unless you are asked not to (looking at you, C).
Know how to instantiate a 2D array, e.g., [[1, 2, 3], [4, 5, 6], [7, 8]].
Checking if a value is present in an array is as simple as i in arr.
Understand how copy and deep copy work, the difference between the two, and when to use them. E.g., A = B and A = list(B), where B(list) is a different copy of B (more on that in the future).
Slice is your best bud, use it wisely.

There may be some unmentioned here, but if you know any, I appreciate it if you could share.

Ace the Basics of Arrays: A Step-By-Step Guide

David Mebo — Sun, 26 Feb 2023 09:48:42 +0000

Array Introduction

An array is a contiguous block of memory, and the simplest data structure known so far. It is usually used to represent sequences.
Example:
Given an array A[i], A[i] denotes the (i + 1)th object stored in the array.
With your typical use of arrays, the Time complexity for retrieving and updating data from an array takes O(1) time.

Array Actions

Here, we will look at the Time complexities of inserting and deleting an element of an array, and hopefully, the explanation will be clear enough for anyone to understand.
Also in the future, other aspects of arrays, like modifying/changing an element in an array will be covered. But for now, we will stick to the basics.

Insertion of An Element In An Array

Insertion of new data/element into a full array can be handled by resizing i.e. allocating a new array with additional memory, and copying over the entries from the original array increases the worst-case time of insertion.
But, if the new array has a constant factor larger than the original array, the average Time complexity for insertion is constant O(1), since resizing is infrequent.

Deletion of An Element In An Array

Deletion of an element from an array involves moving all successive elements one over to the left to fill the space left from the deleted/removed element in the array.
The Time complexity to delete/remove an element at index i from an array of length n is O(n - i). The same applies when one is inserting a new element into the array using the same principle.
Examples:
If we have an array/list of elements {1, 2, 3, 4, 5, 6, 7} and we want to remove the element at index 3, to the uninitiated and those who are familiar with languages like COBOL, FORTRAN or AWK (not THAT awk), the value they'd be expecting to get cut off is 3, but if we followed the example given at the intro, the value getting removed is 4. This is because we are following the principle that 4 in the array (we'll call it A) A[4] is the (i + 1)th object stored in the array, where i is the index of the array.
You might have a solid argument if the language(s) you use that follows this principle, but I'm not gonna indulge you on that, take it to the stack overflow overzealous wizards!

Problem(s)

This problem statement gives us an insight of working with arrays (or lists if you are using Python), but for the sake of avoiding confusion on my part, arrays/lists are arrays, unless stated otherwise.
For the question, they'd be structured in an unordered list. Sure looks weird for some leetcode warriors out there, but for us normies, it should make it easier to understand each requirement, whiteboard and explain the complex parts where necessary, which leads to you thinking up a good solution or ask the interviewer the right question(s) for hints that could lead to a potential answer.

Problem 01

The question:

You are given an array of integers
You have to reorder the entries so that even entries appears first
You are required to solve this without adding additional space

If the last option was not an option, we'd simply do the following:

split the array into two sub-arrays called left and right
write a for loop that traverses the array, with a parameter, most likely i
- inside the for loop, we write a conditional to check if the elements (or numbers if you must) is a modulus of 2, i.e. the remainder is 0
- if it is, we add the number to the array (how? append the even number to the left sub-array)
- if it is not a modulus of 2, i.e., there is a remainder of 1+, append to the right sub array
return the values of the two sub-arrays combined.

The Time complexity may be O(n), in which congratulations are in order, but the instructions does not want you to allocate any space to the array.

If you were to follow the instructions to get the Space complexity to be O(1), a third sub-array is needed. The third sub-array will be the original array you are sorting. So, from a point in your original thought process:

the third sub-array (lets call it original) is iterated
from the point where you check for even and odd values, swap the values from original to left or right sub-arrays. This expands the two sub-arrays, and shrinks the original array. No additional space created for the new arrays, just a swap of sorts happening. arrayBasic01.py

#!/usr/bin/env python3
"""O(n) space array i.e. allocated space to the array"""
def even_left(arr):
    left = 0
    right = len(arr) - 1

    while left < right:
        if arr[left] % 2 == 0:
            left += 1
        else:
            arr[left], arr[right] = arr[right], arr[left]
            right -= 1
    return arr

000-testArray.py

#!/usr/bin/env python3
from arrayBasic01 import even_left

arr = [1, 2, 3, 4, 5, 6, 7, 8]

print(even_left(arr))

The code above will output [8, 2, 6, 4, 5, 7, 3, 1].
Note: If you got OCD (feel free to modify) or think this is wrong, stop depending 100% on chatGPT. Its solutions resulted in this output despite it trying to force its 'correct' answer on me (its output was [2, 4, 6, 8, 1, 5, 7, 9] if you're wondering).

What's Going On

What made the Space complexity to be O(1) (chatGPT adamantly says it is impossible despite giving me an answer with O(1) space), is there is a variable that holds the indices (indexes), and a temporary variable for performing swaps.
For Time complexity analysis, since a constant amount of processes is done per entry to the sub-arrays, it is O(n), where n is the length of the array.

To close this entry, I'll drop some tips I read up;

Be comfortable writing code that utilizes subarrays
When operating an array, do not forget that indexes starts from 0
When operating 2D arrays, use parallel logic for rows and columns
Don't worry about order of an array, i.e. they must be equal, or see the note of the problem statement above

For more Array problems, approach and solutions, I'm building a repo of sorts for that, will contain leetcode questions and solutions (basically interview questions). Anyways, till next time.

Relationships in Object-Oriented Programming

David Mebo — Tue, 21 Feb 2023 22:11:48 +0000

So far so good, I talked about abstraction and encapsulation in my previous post, but we don't know yet how to use it to create proper levels of abstractions. There are ways to go about this, and they are called relationships. They are:

Association
Composition
Inheritance
Aggregation

Association

Association is a type of relationship that has that "in a relationship with" relationship. It establishes a relationship between two classes using their objects.
Take this UML diagram below, it shows two classes connected by a line. That line in UML is called an Association, and it fits the use case.

Composition

Composition is the process of collecting several objects together for the purpose of creating a new object.
An example of composition can be seen in the car example of abstraction posted last week. The car object provides the interface needed for the driver, while also providing an interface to the mechanic to "fix" broken parts.

Aggregation

Aggregation is almost similar to composition. The difference between them is that aggregate objects can exist independently of each other.
Also, keep in mind that composition is the same as aggregation and aggregation is a more general form of of composition. Also, any composite relationship is also an aggregate one, but never the other way around.

The UML above is a chess set, which shows how composition relationship (represented with a solid diamond) and aggregate relationships (hollow diamonds) works.
In the UML, we will notice that the board and pieces are stored as a part of the Chess set in exactly the same way a reference to them is stored as an attribute on the chess set. This shows the distinction between aggregation and composition is sometimes irrelevant since they behave in the same way.

Inheritance

Inheritance is a relationship of sorts, where a class can inherit from another class or classes that share the same set of attributes and methods with the supposed class inheriting.
In some languages like Java, the class being inherited from, is either called a superclass or base class.
The class that is inheriting from the base class is called the derived class or subclass. The derived class inherits all the properties and methods, or overrides the ones inherited from the base class.

For example, consider a class called Animal that has properties such as name, age, and methods such as eat() and sleep(). A subclass called Cat can be created that inherits all the properties and methods of Animal, and also has additional properties and methods specific to a cat, such as meow() and climb().

Inheritance helps to reduce code duplication, increase code reuse, and promote a more organized and modular programming style.

On that note, hope it made things clear.

Public and Private Interfaces In OOP

David Mebo — Tue, 14 Feb 2023 13:09:10 +0000

Welcome to another section of OOP with Python. If you read the last post, I talked about OOP and other object-oriented paradigms like OOA and OOD. This time, we'll look at encapsulation and abstraction, and their role in creating public and private interfaces. To further support this, I will be using UML to show them in detail (I will cover UMLs in the not-too-distant future but if you are impatient, you can pick up UML Distilled and read).

Interface

The fundamental purpose of modeling an object is to determine what the public Interface of the object will be. An interface is the collection of attributes/instance variables and methods that other objects can interact with, and have access to. Let's use the television as an example. The TV is an object, and the interface to the TV is the remote control. Each button on the remote represents a method that can be called on the television. When the access these methods, we are not from where the TV gets its signal, the signals are sent from the remote to the TV and other functionalities that make the TV work (speakers). The TV internals hides these things - the workings/implementations that make the TV work - from us.

Encapsulation

The process of hiding these implementations of an object is referred to as encapsulation. But, encapsulation's meaning is completely different. In other terms, it means to hide something, but in programming, it means to create a wrapper on the attributes. The public interface, on the other hand, is essential. It needs to be properly designed as other classes depend on it, meaning a change in the interface will affect those classes using the interface. Other parts can be changed and it will not affect the public interface, but if the interface is altered, it will break an application. To prevent this mistake from happening, one might spot a python variable starting with _. It means that it is not a part of the public interface.

Abstraction

Abstraction is another object-oriented term related to encapsulation and information hiding. Abstraction is the process of encapsulating information with a separate public interface. Any private element can be subject to information hiding. Take a car as an example. A car driver (client) needs to interact with the steering, accelerator, and brakes. The workings of the brakes, engines and the entire work do not matter to the driver, but to a mechanic (programmer), it does. Here are two levels of abstraction for a car from the driver (client) and mechanic (programmer) perspectives.
Note: a leading _ can be used to suggest that it is not a public interface.

Key Takeaways

Overall, the takeaway from this post is that one has to make each model understandable to others and also ourselves in the future whenever we need to revisit and change how things work and interact with other objects.

No use of obnoxious names, like if an attribute should be named instance_id and user_id for easy identification, one goes and use id for everything (because it's an object and it's encapsulated in an object/class won't cut it.)
To make things somewhat easy, you should make sure your objects are nouns, methods verbs, and attributes as nouns or better yet, adjectives. It might be hard to do if you suddenly become conscious of it, but it'll naturally stick with you - like muscle memory - if you practice.
When you design an interface, imagine what you want to be publicly accessible, and what is not. Even for private matters, you decide who you in your circle should know or have access to them privy information. In other words, treat it like it's a real-life scenario. You'd want everyone to know you got a new car but will not let a car painter service its engine. Ah well, till next time. The different relationships in OOP will be covered. In the meantime, keep practicing!

OOP, OOD, and OOA in Python Intro

David Mebo — Tue, 14 Feb 2023 07:32:58 +0000

The definition of an object is no different from an object in real life: a tangible thing one can touch, feel, sense, and manipulate.
Things are different in programming. Objects might not be tangible, and cannot be sensed or felt, but they are models that can do certain things and vice-versa.
Short of it, An object is a collection of data.

Now that we know what an object is, what about object-oriented?
Breaking it down (because that's what we mostly do), oriented, according to the dictionary means direct towards. Piecing both the definitions of an object and oriented, we can say that Object-oriented programming means writing code directed towards moving objects

via Gfycat

Yeah... doesn't make sense, I get it.
The less confusing definition is below;

Object-oriented programming (OOP) is seen as the process of converting a design into a
working program or application that does what it is told to do.

There are more concepts to Object-oriented, like object-oriented design and object-oriented analysis. Don't worry, they are still object-oriented.

Object-oriented Paradigms

Object-oriented analysis(OOA):
This is the process of looking at a problem and identifying the objects and the interactions between the said objects.
This stage is about what needs to be done.

Example;

As a food scientist, I need a website to help users know how much to eat without it becoming a health risk to themselves.

As a visitor, here is what I would like or think is essential for visitors.
Each necessity a visitor wants is highlighted in bold text to signify that it is an object, and the actions of the visitors are in italics:

browse food choice
upload food decisions for the day/week
see recommended foods

You get the idea...
Once analysis/research has been carried out, we move on to the next stage.

Object-oriented design (OOD):
This is the process of taking the results of the analysis above and implementing them. It's at this point does the programmer comes up with wicked-looking names for the objects, defines their expected behavior, and specifies certain behaviors of the objects. Kinda like them team meetings I hear about, starts good, but never end well. Ah well, moving on.

Last is Object-oriented Programming (scroll up for the definition if you missed it)... aaand we are done (not) with this bit. It looks confusing (trust me, I got lost learning for the first time) but over time, you'll get over it. On that note, look out for the next part!

Operators

David Mebo — Tue, 29 Nov 2022 11:11:10 +0000

More challenges given by ALX, more stuff to read about and grasp. Honestly, its overwhelming. Sure, I do have some basic knowledge with JavaScript, should be easy right?
Yeah, it should be, if the challenges did not have conditions I gotta follow. I mean, why do I need to use putchars, puts when I can use printf and call it a day right? Boy, was I Wrong. Enough rant, let's get to documenting what I've learnt.
Reminder: Mostly me documenting stuff, not meant to be an alternative to what you learn (fact-checking maybe) and also, I am talking about C, not JavaScript (even if their syntax seems familiar).

Operators

Operators are symbols that allows a program to perform specific and logical tasks/operations.
There are several types of operators in C:

Arithmetic operators
Relational operators
Logical/boolean operators

Arithmetic operators

Arithmetic operators are mathematical expressions. There are seven of em:

Plus (+)
Minus (-)
Multiplication (*)
Division (/)
Modulus (%)
Increment (++)
Decrement (--)

Arithmetic operators are of two types. Unary and binary operators.
Unary operators are operators that works with an operand. Using the increment operator is a perfect example: foo++

Binary operators on the other hand, works with two or more operands. We use em everyday and everywhere, from calculating the speeds to safely land a spacecraft at NASA to calculating how much tip to give the pizza guy (1 + 1 anyone?)

Relational Operators

Relational operators according to wikipedia, it is a construct that defines some kind of relationship between two entities. Methinks they are right, but swap out entities with operands. Here's a list of em;

> greater than
< less than
>= greater than or equal to
<= less than or equal to
== equal to
!= not equal to

Examples below;

foo == foo
bar > baz

Logical/Boolean Operators

Logical operators are operators used to combine two or more relational operators. They are used with statements (more on that).
Below is a list of them;

Logical AND (&&)
Logical OR (||)
Logical NOT (!)

There are more types of logical operators, like the XOR, AND and OR operators but for my sanity, lets talk about the ones that I end up seeing almost everyday.

Use of The Listed Operators

AND (&&) checks if both conditions in a statement is true. If the first one is false, the entire statement is false, irrespective of if the second condition is true. Example;

foo == foo && baz == baz        /*true*/
foo == bar && baz == baz        /*false*/

OR(||) checks if either conditions given is true, meaning if one of them is false, the entire statement is evaluated as true unless both are false. Example;

foo == bar || baz == baz        /*true*/
foo == bar || bar == baz        /*false*/

NOT(!) checks the conditions passed and returns the opposite value of the argument. Take these snippets;

!(1>2)
!(1<2)

The first snippet says that 1 is greater than 2, which is false. But, there's the NOT operator, which will inverse the value of the argument and that will make it true because 1 is NOT greater than 2.
Going by the same logic for the second snippet, 1 is not less than 2. The result will be false because it is not true.

There are other types of operators, like assignment operators (+=, -=,...), tenary operators, sizeof operators...
Thing is, every language got an operator(s) that's specific/works well for them. Depending on what language syntax you choose to learn, don't mix up their operators. In other words, RTFM or look up some other source if the docs looks like someone tried transferring his/her frustrations onto its readers.

For book recommendation, check out K.N. King's C Programming: A Modern Approach (make sure its the second edition you got). Should be worth the read for both beginners and anyone looking for a refresher.
If you are done with that, pick up K & R ANSI C book. I have heard people say one should start with this book but nah, rather have most of it explained instead of doing a "shoot first, ask questions later" approach (debugging on the first chapter was NOT fun, especially if the issue was obvious if I knew what I was doing).

Ah well, back to real life. New episode of Chainsaw Man out. Need a bit of fun before doing those mock interviews (who in their right mind thought it was a good idea to have several rounds of interviews for entry level roles???)

Rough intro to GCC (Hello, World!)

David Mebo — Wed, 23 Nov 2022 17:00:00 +0000

Write a script that runs a C file through the preprocessor and save the result into another file.
The C file name will be saved in the variable $CFILE
The output should be saved in the file c

That's the first task starting my journey learning C, aside setting up your environment and all. Seems pretty straightforward... till I keyed in man gcc in the terminal. The output? Lets just say I read half-way and gave up. Ended up getting a book on GCC which in my opinion did a better job breaking down the commands and flags eli5 style.

Anyways, C programs go through 4 compilation stages;

Preprocessor
Compiler
Assembler
Linker

Preprocessing

In the preprocessing stage, macros and header files are expanded i.e. you see what you added to the files. Macros? Header files? You see their source codes.
By the way, the preprocessing step creates a file with .i extension. To pass a c file through a preprocessor, the flag you are looking for is -E, command;

gcc -E foo.c

Compilation

Next step is the compilation stage. Here, the preprocessed file is passed through a compiler, which in turn creates source file with an extension '.s', which contains assembly code. The flag here is -S, same command used as the preprocessor but the flags are swapped. Do note though that using the flag will not create an object file, that's the job of the assembler.

Assembler

Third stage, the assembler. This is where assembly code goes from barely understandable except by those who learnt about it before I was born to being unreadable by virtually anyone on this planet, unless you are a robot or someone who's dedicated their life following the ways of the machines.
The assembler takes the source file and turns it to an object file which contains machine code. To invoke the assembler, use

as foo.s -o foo.o

This will generate the object file 'foo.o'.

Linker

The final stage is the linker. There's a lot going on under the hood here but the short of it is you invoke gcc followed by the object file one wishes to compile, like this;

gcc foo.o

The command generates an executable called a.out. To run the executable, point to the path where the executable is located, followed by the executable name on your terminal. Hit enter and the results of your C file should display on your terminal.

Back to the question, following the instructions, you'll realize you need two commands/flags. One for passing the file through a preprocessor, another for naming the output of the file
In summary, the answer's;

gcc -E $CFILE -o c

Hopefully the rest of the task makes perfect sense to you (except the advanced task maybe, had to check the man page and wikipedia to figure it out).

P.s: Blog post(s) are kinda like a journal to me and I am not in any way looking to educate anyone. It's not in me. Besides, there are lots of materials out there (I will gladly share the ones I used, they'd be mostly books, the occasional diving into the man pages and maybe stackoverflow and stackexchange).