From Nand To OS

My journey with trying to take computer science, computer engineering, electrical engineering and physics more seriously

The Beginning

30/7/2025, I've never had a problem with learning programming languages, i've been programming for years now but as of recently i really wanted to get into how the code itself is processed in the hardware side of things. Of course i always knew about the very basics, the basic functions of each of the components, and things such as transistors, resistors and diodes. But i really wanted to do a deep dive into this science, electrical engineering has always been my dream study. This is my journal, it will last from today, to around June 2027. My end goal is to create an operating system. Along the way i'll be practicing with breadboards and microcontrollers (Arduino Uno), the course Nand2Tetris, learning assembly and enhancing my knowledge of C++ (i rlly dont know anything besides the VERY basics and some reverse engineering), designing my own circuits and finally making the OS as i said.

Preface

1/8/2025, i'm about to start learning about how to use my arduino and breadboard/everything else. As for theoretical stuff, my friends suggest watching the CS50 online course by Harvard, to me it looks like no new information but i'll give all the lessons that interest me (Cuz let me tell ya, i don't wanna watch an entire lecture of Scratch and python). I'll also check out Nand2Tetris and other online resources.

CS50

3/8/2025 I just finished CS50x 2025 Week 1, i skipped week 0 because 8 year old me already knew scratch. I have to admit i already knew all of this, C was the first programming language i picked up after Lua but the course is extremely well put together for me to Want to continue watching it, and the future topics very much interest me

I will be skipping week 6

Week 1 is just titled C, first he spoke about printf obviously, and bash commands. Then header files and with that introduced the CS50 library. Quick rant but i heavily dislike when courses use their own third party library, yk? I'd much rather be taught how to do it the regular way but AIGHT, the CS50 library included get_string, get_int, get_char, get_long, get_float, get_double Etc. He spoke about conditionals, else and else if, and about operators and variables. And finally loops, for loops, while and do while loops. Later he did some examples with loops and printf for doing ascii super mario level design stuff (You'll see about that in the problems) and the most barebones calculator. Speaking of the problems, there's problem sets at the end of each lecture.

CS50 Week 1 Problems

The first problem set goes like this

'In a file called hello.c, in a folder called world, implement a program in C that prints hello, world\n, and that’s it!'

bet

In a file called hello.c, in a folder called me, implement a program in C that prompts the user for their name and then says hello to that user. For instance, if the user’s name is Adele, your program should print hello, Adele\n!

bet x2

It's no shocker that it's highlighted as errors, as Visual Studio (Yes i use microsoft software cuz i am a noob) doesn't have the cs50 library, and cs50 allows for uses of 'get_string' and yk ACTUAL STRINGS, as in strings don't actually exist in C and are just arrays of single characters/chars

but alas this is what they want so here

i'm doing the more comfortable ones of course because i am more comfortable

PAUSE

I'll need to find a way to add cs50.h to Visual Studio, i've opened the cs50.h files in VS and copypasted the cs50.h file here, in the 'Header files' folder of the project, but it doesnt work ffs. How i've managed to do it is just make a .c file inside the github folder for cs50.h which is just stupid but alright.

Oh right, the github repo isn't a project file, so i can't run it like that... Or whatever. I'll continue tommorow

4/8/2025

dude

Excuse me?!?!? This works??

These errors don't show in VS,,, and they're for cs50.h, IDK MAN

6/8/2025 I went to firefox and gave in, i'm using the online cs50 IDE.

i should really delete opera huh

Anyways let's go;

The feeling more comfortable version, Credit, goes like this;

'A credit (or debit) card, of course, is a plastic card with which you can pay for goods and services. Printed on that card is a number that’s also stored in a database somewhere, so that when your card is used to buy something, the creditor knows whom to bill. There are a lot of people with credit cards in this world, so those numbers are pretty long: American Express uses 15-digit numbers, MasterCard uses 16-digit numbers, and Visa uses 13- and 16-digit numbers. And those are decimal numbers (0 through 9), not binary, which means, for instance, that American Express could print as many as 10^15 = 1,000,000,000,000,000 unique cards! (That’s, um, a quadrillion.)



Actually, that’s a bit of an exaggeration, because credit card numbers actually have some structure to them. All American Express numbers start with 34 or 37; most MasterCard numbers start with 51, 52, 53, 54, or 55 (they also have some other potential starting numbers which we won’t concern ourselves with for this problem); and all Visa numbers start with 4. But credit card numbers also have a “checksum” built into them, a mathematical relationship between at least one number and others. That checksum enables computers (or humans who like math) to detect typos (e.g., transpositions), if not fraudulent numbers, without having to query a database, which can be slow. Of course, a dishonest mathematician could certainly craft a fake number that nonetheless respects the mathematical constraint, so a database lookup is still necessary for more rigorous checks.


In a file called credit.c in a folder called credit, implement a program in C that checks the validity of a given credit card number.


                So what’s the secret formula? Well, most cards use an algorithm invented by Hans Peter Luhn of IBM. According to Luhn’s algorithm, you can determine if a credit card number is (syntactically) valid as follows:



Multiply every other digit by 2, starting with the number’s second-to-last digit, and then add those products’ digits together.

Add the sum to the sum of the digits that weren’t multiplied by 2.

If the total’s last digit is 0 (or, put more formally, if the total modulo 10 is congruent to 0), the number is valid!

That’s kind of confusing, so let’s try an example with David’s Visa: 4003600000000014.



For the sake of discussion, let’s first underline every other digit, starting with the number’s second-to-last digit:



4003600000000014



Okay, let’s multiply each of the underlined digits by 2:



1•2 + 0•2 + 0•2 + 0•2 + 0•2 + 6•2 + 0•2 + 4•2



That gives us:



2 + 0 + 0 + 0 + 0 + 12 + 0 + 8



Now let’s add those products’ digits (i.e., not the products themselves) together:



2 + 0 + 0 + 0 + 0 + 1 + 2 + 0 + 8 = 13



Now let’s add that sum (13) to the sum of the digits that weren’t multiplied by 2 (starting from the end):



13 + 4 + 0 + 0 + 0 + 0 + 0 + 3 + 0 = 20



Yup, the last digit in that sum (20) is a 0, so David’s card is legit!



So, validating credit card numbers isn’t hard, but it does get a bit tedious by hand. Let’s write a program.
In the file called credit.c in the credit directory, write a program that prompts the user for a credit card number and then reports (via printf) whether it is a valid American Express, MasterCard, or Visa card number, per the definitions of each’s format herein. So that we can automate some tests of your code, we ask that your program’s last line of output be AMEX\n or MASTERCARD\n or VISA\n or INVALID\n, nothing more, nothing less. For simplicity, you may assume that the user’s input will be entirely numeric (i.e., devoid of hyphens, as might be printed on an actual card) and that it won’t have leading zeroes. But do not assume that the user’s input will fit in an int! Best to use get_long from CS50’s library to get users’ input. (Why?)



Consider the below representative of how your own program should behave when passed a valid credit card number (sans hyphens).

$ ./credit
Number: 4003600000000014
VISA

Now, get_long itself will reject hyphens (and more) anyway:

$ ./credit
Number: 4003-6000-0000-0014
Number: foo
Number: 4003600000000014
VISA

But it’s up to you to catch inputs that are not credit card numbers (e.g., a phone number), even if numeric:

$ ./credit
Number: 6176292929
INVALID

Test out your program with a whole bunch of inputs, both valid and invalid. (We certainly will!) Here are a few card numbers that PayPal recommends for testing.



If your program behaves incorrectly on some inputs (or doesn’t compile at all), time to debug!'

So, what i wanted to do first was make just a simple calculator for each digit, i appear to be making a horrible mistake here as it's not doing that(?)

spoke too soon i immediately saw my mistake... such a dumbass, alright lets move on

alright the next course of action would be to just throw all of this and make it so that it can get every other digit

Alright, this might be a very unorthodox method but this is what first popped into my head;
'Digit' represents the sum of the digits that AREN'T multiplied by 2 (Starting from the 2nd), and sum represents the sum of the digits that were (starting from the 2nd to last). Now i need to check for the amount of digits and the 2 digits they start with,, Hm.

Alright, this is going to need a lot of optimization but i can't think of a way to do it without making a new loop

Code is getting too big to screenshot + it's not working as it should. I feel like i should give up or it's gonna get really messy really fast

#include 
#include 

int main(void)
{
    long card;
    do
    {
        card = get_long("Credit card number: ");
    }
    while (card < 1);
    int i = card;
    int numbers = 0;
    do
    {
        numbers++;
        i/=10;
    }
    while (i>0);
    int sum = 0;
    int otherdigit = 0;
    int digit = 0;

    do
    {
        digit += card % 10;
        card /= 10;
        otherdigit = card % 10;
        otherdigit *= 2;
        do
        {
            sum += otherdigit % 10;
            otherdigit /= 10;
        }
        while (otherdigit > 0);
        card /= 10;
    }
    while (card > 0);
    digit+=sum;
    if (digit % 10 == 0)
    {
    if (numbers==13 || numbers==16)
    {
        printf("VISA\n");
    }
    else if (numbers==16)
    {
        printf("MASTERCARD\n");
    }
    else if (numbers==15)
    {
        printf("AMEX\n");
    }
}
else
{
    printf("INVALID\n");
}
}

Ive been a puppet, a pauper, a pirate, a poet, a pawn and a king..

alas i should go to the less comfortable version for credit

Suppose you work at a store and a customer gives you $1.00 (100 cents) for candy that costs $0.50 (50 cents). You’ll need to pay them their “change,” the amount leftover after paying for the cost of the candy. When making change, odds are you want to minimize the number of coins you’re dispensing for each customer, lest you run out (or annoy the customer!). In a file called cash.c in a folder called cash, implement a program in C that prints the minimum coins needed to make the given amount of change, in cents, as in the below:

Change owed: 25
1

But prompt the user for an int greater than 0, so that the program works for any amount of change:

Change owed: 70
4

Re-prompt the user, again and again as needed, if their input is not greater than or equal to 0 (or if their input isn’t an int at all!).

Fortunately, computer science has given cashiers everywhere ways to minimize numbers of coins due: greedy algorithms.



According to the National Institute of Standards and Technology (NIST), a greedy algorithm is one “that always takes the best immediate, or local, solution while finding an answer. Greedy algorithms find the overall, or globally, optimal solution for some optimization problems, but may find less-than-optimal solutions for some instances of other problems.”



What’s all that mean? Well, suppose that a cashier owes a customer some change and in that cashier’s drawer are quarters (25¢), dimes (10¢), nickels (5¢), and pennies (1¢). The problem to be solved is to decide which coins and how many of each to hand to the customer. Think of a “greedy” cashier as one who wants to take the biggest bite out of this problem as possible with each coin they take out of the drawer. For instance, if some customer is owed 41¢, the biggest first (i.e., best immediate, or local) bite that can be taken is 25¢. (That bite is “best” inasmuch as it gets us closer to 0¢ faster than any other coin would.) Note that a bite of this size would whittle what was a 41¢ problem down to a 16¢ problem, since 41 - 25 = 16. That is, the remainder is a similar but smaller problem. Needless to say, another 25¢ bite would be too big (assuming the cashier prefers not to lose money), and so our greedy cashier would move on to a bite of size 10¢, leaving him or her with a 6¢ problem. At that point, greed calls for one 5¢ bite followed by one 1¢ bite, at which point the problem is solved. The customer receives one quarter, one dime, one nickel, and one penny: four coins in total.



It turns out that this greedy approach (i.e., algorithm) is not only locally optimal but also globally so for America’s currency (and also the European Union’s). That is, so long as a cashier has enough of each coin, this largest-to-smallest approach will yield the fewest coins possible. How few? Well, you tell us!

OKAY, this isn't hard, i can do this

#include 
#include 

int main(void)
{
    int change = 0;
    do
    {
        change = get_int("Change owed: ");
    }
    while (change < 0);
    int pennies = 0;
    while (change >= 25)
    {
        pennies++;
        change-=25;
    }
    while (change >= 10)
    {
        pennies++;
        change-=10;
    }
    while (change >= 5)
    {
        pennies++;
        change-=5;
    }
    while (change >= 1)
    {
        pennies++;
        change-=1;
    }
    printf("%i\n",pennies);
}

As i said, not hard at all, i just feel as if i could optimize this a lot better. Alas, let's move onto mario, i won't make the same mistake again, i'll choose the less comfortable version and then the more comfortable version if i'm doing good.

This does it, however one issue, it needs to be horizontally flipped. The # at the start needs to start the end of the row ifyk what im trying to say

Alright i literally just went out on a limb and did it, the thought process was i should print a blank space for every n-row. I was completely expecting this to not work but okay

Now, it's time for the more comfortable mario problem and i'll move onto Week 2. First though, Chess + Food + Chocolate milk break.

Chocolate milk wasn't a good idea... I'm having toilet issues,, ANYWAys HARDER MARIO PROBLEM LET'S GO

In a file called mario.c in a folder called mario-more, implement a program in C that recreates that pyramid, using hashes (#) for bricks, as in the below:


   #  #
  ##  ##
 ###  ###
####  ####

And let’s allow the user to decide just how tall the pyramids should be by first prompting them for a positive int between, say, 1 and 8, inclusive.

Examples



Here’s how the program might work if the user inputs 8 when prompted:

$ ./mario
Height: 8
       #  #
      ##  ##
     ###  ###
    ####  ####
   #####  #####
  ######  ######
 #######  #######
########  ########

Here’s how the program might work if the user inputs 4 when prompted:

$ ./mario
Height: 4
   #  #
  ##  ##
 ###  ###
####  ####

Here’s how the program might work if the user inputs 2 when prompted:

$ ./mario
Height: 2
 #  #
##  ##

And here’s how the program might work if the user inputs 1 when prompted:

$ ./mario
Height: 1
#  #

If the user doesn’t, in fact, input a positive integer between 1 and 8, inclusive, when prompted, the program should re-prompt the user until they cooperate:

$ ./mario
Height: -1
Height: 0
Height: 42
Height: 50
Height: 4
   #  #
  ##  ##
 ###  ###
####  ####

Notice that width of the “gap” between adjacent pyramids is equal to the width of two hashes, irrespective of the pyramids’ heights.

Alright, this doesn't sound bad at all, considering i'd already done it the other way around lol i just gotta repeat that again and have the gap between them, tho i definetly feel like there's gonna be a way more optimized way for this

#include 
#include 

int main(void)
{
    int n = 0;
    do
    {
        n = get_int("Height: ");
    }
    while (n < 1 || n > 8);
    int row = 1;
    for (int i = 0; i < n; i++)
    {
        for (int c = 0; c < n-row; c++)
        {
            printf(" ");
        }
        for (int h = 0; h < row; h++)
        {
            printf("#");
        }
        for (int y = 0; y < 2; y++)
        {
            printf(" ");
        }
        for (int z = 0; z < row; z++)
        {
            printf("#");
        }
        row++;
        printf("\n");
    }
}

This did it, pretty easily, i feel like i could've done the 2 row blank space wayyy better but alright

3/4 problems completed, i feel like that's good for now

Before i move onto Week 2, i'll watch the walkthrough for credit, as it's not a explicit 'answer', it just gives you a foundation for your thinking process, and i'll try to re-do it with the knowledge from the walkthrough, hopefully

Alright so, apparently, there were red herrings, im looking at my code rn and it wasn't so bad, i was able to calculate the checksum, the length of the card isn't important apparently, only the first two letters are for determining which kind of card it is. I'll try it.

#include 
#include 

int main(void)
{
    long card;
    do
    {
        card = get_long("Credit card number: ");
    }
    while (card < 1);
    int i = card;
    int sum = 0;
    int otherdigit = 0;
    int digit = 0;

    do
    {
        digit += card % 10;
        card /= 10;
        otherdigit = card % 10;
        otherdigit *= 2;
        do
        {
            sum += otherdigit % 10;
            otherdigit /= 10;
        }
        while (otherdigit > 0);
        card /= 10;
    }
    while (card > 0);
    digit += sum;
    if (digit % 10 == 0)
    {
        printf("VALID\n");
    }
    else
    {
        printf("INVALID\n");
    }
}

I rewrote my code and got rid of all the length calculating bullshit and stripped it down to if the checksum works or if it doesn't work, now getting the first two numbers will be harder..

Well i kinda lied it's not hard, of course it's a do while loop divide by 10 till you get the first two but like there MUST be a better way right? I'm trying so hard not to use things that AREN'T taught in the lectures because that'd be cheating, but i think it is the only way to do it

Update: Yes, it is..

#include 
#include 

int main(void)
{
    long card;
    do
    {
        card = get_long("Credit card number: ");
    }
    while (card < 1);
    long i = card;
    int z = 0;
    int sum = 0;
    int otherdigit = 0;
    int digit = 0;
    do
    {
        i /= 10;
        z++;
    }
    while (i > 100);
    printf("%li\n", i);

    do
    {
        digit += card % 10;
        card /= 10;
        otherdigit = card % 10;
        otherdigit *= 2;
        do
        {
            sum += otherdigit % 10;
            otherdigit /= 10;
        }
        while (otherdigit > 0);
        card /= 10;
    }
    while (card > 0);
    digit += sum;
    if (digit % 10 == 0)
    {
        if (i == 34 || i == 37)
        {
            printf("AMEX\n");
        }
        else if (i == 51 || i == 52 || i == 53 || i == 54 || i == 55)
        {
            printf("MASTERCARD\n");
        }
        else if (i / 10 == 4)
        {
            printf("VISA\n");
        }
    }
    else
    {
        printf("INVALID\n");
    }
}

GOD BLESS AMERICA, i'm counting this, we went 4/4 today. It was easier than i thought, i shouldnt've been so easily disheartened

CS50 Week 2

7/8/2025 No david malan, i will NOT use AI to help me with my problem set, fuck is you on about

Week 2 is over, it's titled Arrays, opens with talking about compiling and the 'make' command that runs the clang compiler, then he glances over assembly language as a part of compiling (Learning assembly is one of the goals of this whole journey too, but unfortunately this is probably the only time its mentioned lol), then about types and their physical size in memory. Then actual arrays and multiple examples of sorts. And he actually touched on the fact that strings are just arrays of chars and that a string type isn't actually in stdio.h and a product of cs50.h, i can't wait to stop using cs50.h i hate it sm i HATE IT I WANNA LEARN REAL C

He also talked about ASCII codes and turning lowercase letters to uppercase and then command line arguments, and with that exit statues and actually returning ints with int main(void). And finally encryption, specifically touching on the caesar cipher and that's prooobably gonna be a part of the problem set for this week. Either way, watching this took a whole day cuz i was busy with wplace.live and other stuff (Friends,, smh.) so it'll have to do tommorow

9/8/2025 skipped yesterday oops, sorry about that, again, wplace has taken over my life T_T. Also i've been writing for a different project but besides that, let's get into it.

we have 4 problems yet again, alright let's get into Scrabble:

The first thing that comes to mind is to make a if statement for each letter, that can't be optimized, but, let's try it

oh hell nah this isn't gonna work

The function itself probably isn't the most optimized way to do this

But, this works, i have to admit i cheated and i won't be counting this one for today. i wrote everything myself but the idea to use abstraction wasnt my own idea. I'm very dissapointed because this is easy, i haven't been using functions outside of int main so i need to add this to my process, onto the next one. Readability

Alright so, Have the user input a string, have 2 counters, one for each letter and one for each word, the words will be counted for every " " char there is in the string. For the second part, the sentences will be counted for every "!", "." and "?". I think i figuh'd it out

i did this funny thing where im ending the loop if the words gets to 100 cuz all the measurements are measured within 100 words so i think that's a le smart choice on my part

now time for the final calculation and for me to see if this even works

oh and ofc increase n every loop

wait hold on i mhaving brain farts (or maybe its just late), what does average number of letters per 100 words mean??

I think it's just late,,, the average number of letters per word is letters/words, obviously, so this just means it's that x100? The sentencing just threw me off

Alr i just noticed i forgot a quote down there and i shouldn't use >= for the whitespace AND i shouldnt use double quotes for the single chars in the last if... And finally a semicolon.

nvm

this is my band aid fix

it compiles fine, however the lecture uses this as a Grade 10 Example...

I changed the formula to this and now it works as intended, amazing, i'll be continuing tommorow

11/8/2025 FUUUCK i lazy'd out another day, ffs, let's continue to 'Caesar'.. I should really be more serious about this, although at the same time i should take it easy

28/8/2025

Well, hello, It's been 17 days and i still haven't finished week 2. Over an entire month i only did 1 and a half weeks. I'd call this a failure, to punish myself i'll be rewatching week 1 and 2 and reading through my notes again and i'll finally finish this weeks problem.

i don't wanna say i've been busy, i have been doing OTHER things but i have lazy'd out of it, god dammnit! Well, cya tommorow when i come back to this week. Oh and a funny thing, i have had a dream a few nights ago where i finished this problem but again i'm a LAZY FUCK! and didint even do it even though the answer literally came to me in a dream

5/9/2025 AND WERE BACK! i have reviewed my previous code, and it's time to COMMIT. The past week was the first week of school, i talked about it on my blog, was busy with a web design project yada yada.
Let's actually get into ceasar. It's week 2, and it's been going on for a while, but of course, after about a MONTH we're back at it! Idk why this caesar question made such a bump in the mission but, let's get into it, i've already shown what it wants from us, so;

first thing to do is to make it so if you don't input one argument, it wont let you proceed, easy enough! Now i should make it so it only lets you input integers, again it should be easy enough(?) I just have to do if argc < 0?

ALL RIGHT! that did it! Now let's get that string!


    string plaintext = get_string("Plaintext:  ");

Though, now i gotta make a function that encrypts that string with the caesar cipher algorithm..

first and foremost i just gotta do this, this might be the wrong thing to do but aiye this is how im gonna do going over 26 because it sounds logical for me


pointer and integer ('string' (aka 'char *') and 'int')

Ahhhh

int main(int argc, string argv[])
{
    int n=0;
    if (argc != 2)
    {
        printf("Usage: ./caesar key\n");
        return 1;
    } else if (argc < 0)
    {
        printf("Usage: ./caesar key\n");
        return 1;
    }
    string plaintext = get_string("Plaintext:  ");
    do
    {
        argv[2] -= 26;
    }
    while (argv[2] >= 26)
    while (plaintext[n] != '\0')
    {
        n++;
    }
    for (int i = 0; i< (blankspace due to html thinking im trying to do a tag)n; i++
        {
            plaintext[i]+=argv[2]
        }
}

this is my logic for now, i gotta change what im doing with the do while then

Hmmm maybe if i just change it to int main(int argc, int argv[])

Ahh shucks it has to be a string/char array

And also i should use argv[1] instead of argv[2] because the program name is argv[0] not argv[1]

i'm just realizing that this is the less comfortable version...

#include 
#include 

int main(int argc, string argv[])
{
    int n=0;
    if (argc != 2)
    {
        printf("Usage: ./caesar key\n");
        return 1;
    } else if (argc < 0)
    {
        printf("Usage: ./caesar key\n");
        return 1;
    }
    string plaintext = get_string("Plaintext:  ");
    while (plaintext[n] != '\0')
    {
        n++;
    }
    printf("Ciphertext: ");

    for (int i=0; i< n; i++)
    {
        if (plaintext[i] >= 'a' && plaintext[i] <= 'z')
        {
            printf("%c",plaintext[i]-argv[1])
        }
    }
    printf("\n");
}

This meets me with the error at the end, plaintext[i] is a char and argv[1] is a string.. That's, true, but argv[1] is inputted as an int!! A number!!

this would be so much easier if it wasnt a command terminal prompt

This works fine i just NEED to get the argv into a integer...

6/8/2025 it's 1 am,,, i just saw this.

sighhhh, 3rd library :| okay..
i forgot how addicting this is, like if you get out of the habit it's hard to get back into it but when you do its hard to stop, i feel like thats what happened with me i was on a good roll and then i just stopped for a month

#include 
#include 
#include 

int main(int argc, string argv[])
{
    int n=0;
    if (argc != 2)
    {
        printf("Usage: ./caesar key\n");
        return 1;
    }
    string plaintext = get_string("Plaintext:  ");
    while (plaintext[n] != '\0')
    {
        n++;
    }
    printf("Ciphertext: ");
    int cipher = atoi(argv[1]);
    for (int i=0; i< n; i++)
    {
        if (plaintext[i] >= 'a' && plaintext[i] <= 'z')
        {
            printf("%c",plaintext[i]+cipher);
        }
        else if (plaintext[i] >= 'A' && plaintext[i] <= 'Z')
        {
            printf("%c",plaintext[i]+cipher);
        }
        else
        {
            printf("%c",plaintext[i]);
        }
    }
    printf("\n");
}

This looks and works OKAY! the main point i need to fix is, to fix overflows i dont need to remove 26 if its above 26, cause like... 30-26 is 4 and if its Z, Z+4 is gonna be ^

CS50 gave us a formula for that! And i am greatful, though, it is late. I will finish this week FINALLY TOMMOROW! and then we can move onto week 3 (again, finally), if this was such a headache i wonder how the next one will be like, although i think it's just because after a month i got dusty.

Hello! Good nights sleep, time to just add the formula and this should finally be over

This doesn't work, because, lets say i=20 and cipher is 5, it'd still be +25. This system doesn't account for the placement in the alphabet but for the placement in the plaintext string, hm.

This looks stupid but NOW a or A is 0, b is 1 etc etc.. Because a is 97 on the ascii chart and A is 66. But now new problem! I have to make it reach back around because it can still be like plaintext[10]+17 yk

But first, breakfast break. This is going to be the 39th daily breakfast club (Those who know:)

AND WERE BACK! Alright, i got an idea, another %26 at the end

 printf("%c", (plaintext[i] + ((cipher + (plaintext[i] - 97)) % 26)) % 26);

hmm this doesn't work

The worst is happening.
i will have to make a function for this.

8/9/2025 This project will be put on hold while we're working on a seperate project, it will be in my full attention after the game is out.