DEV Community: Kartik Kumar

cs50x week 9 Flask

Kartik Kumar — Tue, 10 Dec 2024 10:01:06 +0000

In this week I learned flask microweb framework which is built in python language. It is easy to understand and use.

Problems:
1) Birthdays : In this problem our task is to get the data from user, store in the database and finally fetch the records and display to the user.

2) Finance : This problem was also not very much difficult but it was lengthy as I have to create lot of pages as well as tables in database. But the main thing was same storing the data to database and fetching.

cs50x week 8 HTML CSS JS

Kartik Kumar — Tue, 10 Dec 2024 09:57:18 +0000

It was a quite easy week for me as I already knew basics of html css and javascript.

Only static sites were built in this week.

cs50x week 7 SQL

Kartik Kumar — Wed, 13 Nov 2024 11:10:20 +0000

This week is very easy and interesting as we have to just query the data by running the sql commands.

Problems:
1) Songs - Simple problem
2) Movies - Simple problem
3) Fiftyville - This problem was very interesting till now as it gives the real world problem to solve which is to investigate the crime and find who the real theif is.

cs50x week 6 Python

Kartik Kumar — Sun, 27 Oct 2024 14:38:27 +0000

This week was a transition to a more higher level language than C. Yes I am talking about Python.

Actually everyone says it is easy but it was hard for me because I had already done C very well and Python is just ruining all those deep concepts. I hope those can relate with me who has done C.

Anyway I completed.

Problem sets:

All the problems were same as in the C except the last one DNA.
DNA : This problem was challenging to me because of the new syntax of the python language.

cs50x week5 Data Structures

Kartik Kumar — Mon, 14 Oct 2024 23:50:31 +0000

What I learned till now:

Till now I am done with the c language.
Be slow and try to understand the problem first completely, then take pen and paper and brainstorm a little bit & then jump onto the computer to write code.
Pseudo code really Helps!

Problem sets:
1) inheritance - Found difficult to me, maybe because I was too busy in other work related to my college so not able to focus properly on that problem.
2) speller - Problem was easy to solve but hard to understand but finally did that.

cs50x week4 Memory

Kartik Kumar — Mon, 30 Sep 2024 09:23:02 +0000

This week lecture took me 3-4 times of watching again and again to understand the concept of pointers(basically file pointers).
The Practice Problems were also too much harder than the previous weeks.

Problem sets:
1) Volume = This problem was hard for me because of lack of understanding of file pointers. I watched file pointer video part again and again and understood what the functions actually do and what is the meaning of their arguments.
2) Filter-less = This problem was not that much hard but the subsection(Blur function) of the problem was very very time taking and hard. This function uses the strategy of box blur where we have to calculate the new pixel value from the average of its surrounding pixel's original value including itself.
-Here is the code which I had implemented to solve this problem with the help of cs50.ai

// Blur image
void blur(int height, int width, RGBTRIPLE image[height][width])
{
    /*created temproray matrix for storing the new values beacause we have to calcluate the new
     values from the original values in image*/
    RGBTRIPLE temp[height][width];
    for (int i = 0; i < height; i++) // for iterating rows
    {
        for (int j = 0; j < width; j++) // for iterating columns
        {
            //*************************1) HANDLING THE CORNERS***************************
            //----------1.1) for the TOP-LEFT pixel-----------
            if (i == 0 && j == 0)
            {
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = 0; r < 2; r++)
                {
                    for (int c = 0; c < 2; c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 4.0);
                temp[i][j].rgbtGreen = round(green / 4.0);
                temp[i][j].rgbtBlue = round(blue / 4.0);
            } //---------------------------------------------------

            //----------1.2) for TOP-RIGHT pixel------------
            if (i == 0 && j == (width - 1))
            {
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = 0; r < 2; r++)
                {
                    for (int c = (width - 2); c < width; c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 4.0);
                temp[i][j].rgbtGreen = round(green / 4.0);
                temp[i][j].rgbtBlue = round(blue / 4.0);
            } //-----------------------------------------------------

            //----------1.3) for BOTTOM-LEFT pixel------------
            if (i == (height - 1) && j == 0)
            {
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = (height - 2); r < height; r++)
                {
                    for (int c = 0; c < 2; c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 4.0);
                temp[i][j].rgbtGreen = round(green / 4.0);
                temp[i][j].rgbtBlue = round(blue / 4.0);
            } //------------------------------------------------------

            //----------1.4) for BOTTOM-RIGHT pixel------------
            if (i == (height - 1) && j == (width - 1))
            {
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = (height - 2); r < height; r++)
                {
                    for (int c = (width - 2); c < width; c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 4.0);
                temp[i][j].rgbtGreen = round(green / 4.0);
                temp[i][j].rgbtBlue = round(blue / 4.0);
            } //------------------------------------------------------
            //*******************************************************************************

            //*****************************2)HANDLING THE EDGES************************************

            //----------2.1)HANDLING THE TOP ROW EDGES ---------------
            if (i == 0 && j != 0 && j != (width - 1))
            {
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = i; r < 2; r++)
                {
                    for (int c = (j - 1); c <= (j + 1); c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 6.0);
                temp[i][j].rgbtGreen = round(green / 6.0);
                temp[i][j].rgbtBlue = round(blue / 6.0);
            }
            //----------------------------------------------------

            //----------2.2)HANDLING THE BOTTOM ROW EDGES ---------------
            if (i == (height - 1) && j != 0 && j != (width - 1))
            {
                // ex i[4]j[2]
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = (i - 1); r < height; r++)
                {
                    for (int c = (j - 1); c <= (j + 1); c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 6.0);
                temp[i][j].rgbtGreen = round(green / 6.0);
                temp[i][j].rgbtBlue = round(blue / 6.0);
            }
            //----------------------------------------------------

            //----------2.3)HANDLING THE LEFT COLUMN EDGES ---------------
            if (i != 0 && i != (height - 1) && j == 0)
            {
                // ex i[2]j[0]
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = (i - 1); r <= (i + 1); r++)
                {
                    for (int c = 0; c <= (j + 1); c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 6.0);
                temp[i][j].rgbtGreen = round(green / 6.0);
                temp[i][j].rgbtBlue = round(blue / 6.0);
            }
            //----------------------------------------------------
            //----------2.4)HANDLING THE RIGHT COLUMN EDGES ---------------
            if (i != 0 && i != (height - 1) && j == (width - 1))
            {
                // ex i[2]j[3]
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = (i - 1); r <= (i + 1); r++)
                {
                    for (int c = (j - 1); c < width; c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 6.0);
                temp[i][j].rgbtGreen = round(green / 6.0);
                temp[i][j].rgbtBlue = round(blue / 6.0);
            }
            //----------------------------------------------------

            //*****************HANDLING THE INNER PART************************
            if (i != 0 && i != (height - 1) && j != 0 && j != (width - 1))
            {
                // ex i[3]j[2]
                float red = 0.0, green = 0.0, blue = 0.0;
                for (int r = (i - 1); r <= (i + 1); r++)
                {
                    for (int c = (j - 1); c <= (j + 1); c++)
                    {
                        red = red + image[r][c].rgbtRed;
                        green = green + image[r][c].rgbtGreen;
                        blue = blue + image[r][c].rgbtBlue;
                    }
                }
                temp[i][j].rgbtRed = round(red / 9.0);
                temp[i][j].rgbtGreen = round(green / 9.0);
                temp[i][j].rgbtBlue = round(blue / 9.0);
            }
            //*****************************************************************
        }
    }
    // copying the temp[height][width] to image[height][width]
    for (int i = 0; i < height; i++)
    {
        for (int j = 0; j < width; j++)
        {
            image[i][j].rgbtRed = temp[i][j].rgbtRed;
            image[i][j].rgbtGreen = temp[i][j].rgbtGreen;
            image[i][j].rgbtBlue = temp[i][j].rgbtBlue;
        }
    }
    return;
}

3)Filter-more = Skipped :-)
4)Recover = In this problem I have recovered the jpg images from the card.raw which is a file format used by digital cameras to store back to back images. This uses fat file system in which one block is of 512 bytes and so on. Overall this problem was very interesting and very little hard.

Lastly the one thing that i learned till now is to write a clear pseudo code, understand the problem and then code it.

cs50x week3 ALGORITHMS

Kartik Kumar — Tue, 17 Sep 2024 16:39:33 +0000

As the weeks are passing, more challenges are coming in solving the problem sets.
This week 3 was about the algorithms. The challenging part for me in this week was to understanding the concept of time complexity notations like BIG O , Omega and theta.

Also got familiar with searching and sorting algorithms.
A) Linear search - we compare required element with each element in the list until we found.

B) Binary search - list must be sorted to apply binary search. then we start from middle and check if the required element is in the left part or right , then again we divide and conquer.

C) Bubble Sort - We usually bubbles the highest element to the last of the list. Procedure is swapping the adjacent elements if not in order in whole list. Then repeat again but not checking the sorted elements. If no swaps in first pass then elements are sorted.

D) Selection Sort - In this we search the smallest element from the list of unsorted array and swaps the smallest element with the first element of the unsorted array.

E) Merge Sort - In this we simply divide the list in two, then sort the left half and then right half and then merge.

Problem sets:
1) sort = In this problem , we have to find out from the three sorting programs that which program is using which sorting algorithm by the concept of time complexity.
2) Plurality = In this problem, we just have to create a voting system where n number of voters vote for the x number of candidates and whoever candidate gets more vote is the winner.
3) Runoff = It the another voting system where each voter can vote by setting preferences for the candidates and on the basis of that preferences we have to declare the winner.
4) Tideman = It was another voting system but very confusing so I left it for later.

cs50x week2 ARRAYS

Kartik Kumar — Mon, 09 Sep 2024 10:40:56 +0000

This week was based on the arrays. Nothing new about it because I have a good knowledge of what an array or 2d array is.

-Basically It was a very good revision of my arrays.

What new I learned??

Preprocessing, Compiling, Assembling and linking [Also knew about these concepts before but this was deep dive]
Debugger

Problem sets:
1) scrabble = It was easy but i was hurrying, but at the end i did it. we just assign some points to the alphabets and calculates the points on the basis of that and declares wins , tie or lose when 2 users enters a word.
2) readibility = In this problem we just finds the readibility level of the text by some algorithms. The thing that i didn't understood first was the average of characters per 100 words.
3) caesar = It was easy. We just have to encrypt the data by the key user enters by just moving that much key forward. ex- key is 2 then a will become c. and if key is 3 then d will become g and so on.
4) substitution = I faced difficulty in it so i left it for later.

cs50X week1 C

Kartik Kumar — Tue, 27 Aug 2024 09:33:58 +0000

In the second week I developed new skills like logic building and much more. Started with the c language basic things like ---

variables,
datatypes,
operators [arithmetic, logical, relational and ternary] ,
functions,
loops,
conditionals [If-else and switch].

I learned how to approach problem :

First understand the problem thoroughly
Take pen and paper, spend some time on writing pseudo code for that problem.
Think how to implement that in program.
Start with small steps. You cannot think all the solution of problem before writing code. You must start writing code and then the problems start coming so as the ideas to solve them.
I have to focus more on understanding loops , if-else while giving conditions. Sometimes I get confused what the expression actually mean here.

Lastly but most most important:

design50 taught me to write the code effectively[use abstraction, comments for future, break tasks into small functions, keep main function clean].
style50 taught me to write code so it look neat and clean.
check50 taught me to test my code with different inputs and conditions.
cs50.ai and cs50.dev was very helpful throughout this all.

Problem sets:
1) Hello, world = Very easy, just print "Hello world".
2) Hello, It’s Me = getting name input and printing hello [name]
3) mario-less = Printed right aligned pyramid
4) mario-more = Printed left + right aligned pyramid
5) cash = According to the american currency, we have to tell how many coins will be returned by seeing the change owed.
6) credit = This was very time taking but interesting and taught how the credit card numbers are actually has a mathematical relation between them.

cs50X week0 SCRATCH

Kartik Kumar — Sun, 25 Aug 2024 13:54:10 +0000

I have started cs50x course on 15 August which is about Introduction to computer science. I have taken this course because I wanted to improve my core basics in CS and this is provided by the Harvard University taught by David J Malan which is also providing the certificate upon completion. Before this course, I was in the endless loop of tutorials from the YouTube, which were good but don't provide any step by step guidance due to which I had wasted my lots and lots of time and ended up having expertise in nothing.

So here is what I have learned after week0 project completion:

Basics about computer [unary, binary 0's and 1's, ASCII, UNICODE, How computer store text, images, videos and audios]
Scratch [a visual programming language]
Building logic and Ideas
Abstraction [Hiding the complex parts]
Ended up with creating a game in scratch named Bat In Space