DEV Community: Kathan Vakharia

Rotate Image - LeetCode

Kathan Vakharia — Sat, 01 Jul 2023 11:18:48 +0000

Problem Description

🔗 Link to Question: https://leetcode.com/problems/rotate-image/editorial/

You are given an n x n 2D matrix representing an image, rotate the image by 90 degrees (clockwise).

Observation 🔎

Naive Approach

Observe that the ith col turns into ith row in reversed form
Create a New Matrix and use it to update the original matrix.

Code

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n=matrix.size();
        auto v = matrix;

        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                matrix[j][n-i-1] = v[i][j];
            }
        }
    }
};

Complexity Analysis

Time: $O(n^2)$
Space: $O(n^2)$

Using Matrix Operations

Transpose the Matrix
- Now columns ↔ rows are interchanged Or we’ve performed a reverse operation around the diagonals.
Reverse the Rows.

We are just exploiting the fact that columns are turned into rows in reversed fashion.

Code

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n=matrix.size();

        //Transpose the Matrix
        transpose(matrix);

        //Reverse the rows
        for(int i=0; i<n; i++)
        {
            reverse(matrix[i].begin(), matrix[i].end());
        }
    }

    //Reverse around the Diagonal
    void transpose(vector<vector<int>>& matrix)
    {
        int n=matrix.size();
        for(int i=0; i<n; i++)
        {
            //[0..i-1] columns are correctly modified
            for(int j=i; j<n; j++)
            {
                swap(matrix[i][j], matrix[j][i]);
            }
            //After modifying ith row, ith col is also correctly modified
        }
    }
};

Complexity Analysis

Time: $O(n^2)$
Space: $O (1)$

Next Permutation - O(n) Solution

Kathan Vakharia — Sat, 24 Jun 2023 12:34:04 +0000

Problem Description

🔗 Link to Question: Next Permutation | Practice | GeeksforGeeks

Implement the next permutation, which rearranges the list of numbers into Lexicographically next greater permutation of list of numbers. If such arrangement is not possible, it must be rearranged to the lowest possible order i.e. sorted in an ascending order. You are given an list of numbers arr[ ] of size N.

Brute Force and STL Approach

The brute force approach would be to enumerate all the permutations and store them in a list in sorted order. Then we can look for the given “permutation” and return the next permutation in the list. If our permutation is the last one, then return the first permutation. This is an O(n*n!) time complexity approach with space complexity of O(n!) too. This is not the desired approach!
If you know, C++ STL has a function next_permutation(nums.begin(), nums.end()); to find the next permutation of given array in-place. The time complexity of this function is O(n) with a space complexity of O(1).
- The Interviewer will ask you to implement this function when you present this solution! Let’s do that.

Optimal Approach

Traverse the array from right.
Once, we find 'i' such that A[i] > A[i-1],The sub-array A[i...n-1] is in DSC order and
- To get next permutation:
- Swap A[i-1] with element just larger than it from A[i...n-1].
- Sort A[i...n-1]
After swapping A[i-1] with an element just larger than it from A[i...], DSC order is maintained.
Sorting an array in DSC order is as good as reversing it.

Consider, an example when n=4. The following image demonstrates WHY the algorithm works.

Code

class Solution{
public:
    vector<int> nextPermutation(int n, vector<int> arr){
        int idx = n-1;

        //Find the breaking point
        while(idx > 0 && arr[idx-1] >= arr[idx])
            idx--;

        //'arr' is not the last permuation for these numbers
        if(idx > 0)
        {
            //Swap arr[idx-1] with just greater element than it from
            //arr[idx...n-1)
            int j=n-1;
            while(j>=idx && arr[j] <= arr[idx-1])
                j--;
            swap(arr[j], arr[idx-1]);
        }
        //idx == 0, if arr was the last permuation for these  numbers

        //reverse the portion, arr[idx...n-1]
        reverse(arr.begin() + idx, arr.end());

        return arr;

    }
};

Complexity Analysis

Time: $O (n)$
Space: $O (1)$

Set Matrix Zeroes - Leetcode

Kathan Vakharia — Mon, 05 Jun 2023 22:59:00 +0000

Problem Description

Link to Question: https://leetcode.com/problems/set-matrix-zeroes/description/

Given an n x m integer matrix matrix, if an element is 0, set its entire row and column to 0's.

Using a New Matrix

Create a new matrix → new_matrix.
Traverse the matrix , whenever a 0 is encountered, set the corresponding row and column in the new_matrix to be zero.

Code

#include <bits/stdc++.h>

void set_zero(vector<vector<int>>& matrix, int row, int col)
{
    int n=matrix.size();
    int m=matrix[0].size();

    for(int i=0; i<n; i++)
        matrix[i][col] = 0;
    for(int j=0; j<m; j++)
        matrix[row][j] = 0;
}
void setZeros(vector<vector<int>> &matrix)
{
    //Create a new matrix
    auto v = matrix;

    int n=matrix.size(); //# rows
    int m=matrix[0].size(); //# cols
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            if(matrix[i][j]==0)
            {
                set_zero(v, i, j);
            }
        }
    }
    matrix = v;

}

Complexity Analysis

Time: $O (m * n * (m + n))$ , where m+n is the time required to turn corresponding row, and column to 0.
Space: $O (m * n)$ used by new_matrix

Space Improved Solution

We can improve the space, if we just mark the corresponding row and column that needs to be turn into 0s while traversing the matrix. Let’s do that:

Inititialise two flag arrays, row_flag[#rows] , and col_flag[#cols]
- row_flag[i] and col_flag[i] can take either of two values, -1 or 0.
- ‘-1’ means keep this row or col as it is.
- ‘0’ means turn this row or col into 0.
Traverse the matrix. On encountering a 0, mark the corresponding flags.
Now using our flag arrays, make the required cells of the matrix to be ‘0’.

Code

#include <bits/stdc++.h>

void setZeros(vector<vector<int>> &matrix)
{
    int n=matrix.size();
    int m=matrix[0].size();

    vector<int> row_flag(n, -1);
    vector<int> col_flag(m, -1);

    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            if(matrix[i][j]==0)
            {
                //mark the row and column
                row_flag[i]=0;
                col_flag[j]=0;
            }
        }
    }

    //Change the cells of matrix using
    //flag arrays
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
            //Change to '0' if any of the row or col
            //was marked
            if(row_flag[i] == 0 || col_flag[j] == 0)
                matrix[i][j]=0;
        }
    }
}

Complexity Analysis

Time: $O (m * n)$
Space: $O (m + n)$ used by flag arrays.

Optimal Solution

We want to get rid of the space used by our flag arrays. How about using the 0th row and 0th column as flag arrays for marking purposes?

It turns out we can! We need to take care of one little caveat. Since the cell matrix[0][0] can represent two states only (0 and non-zero), so, it can be either part of the col_flag or row_flag. Let’s say. We make it the part of row_flag to mark the 0th row. Then, we require one more variable to handle marking the 0th column. The image makes it more clear.

Here’s the Approach then,

Traverse the matrix, and mark rows and columns which has to be turned 0.
Traverse the matrix [1,1] → [n,m] i.e except first row and first column, and turn a cell 0 if either one of its row or column is marked.
[IMPORTANT] We will modify the 0th row before the 0th column. The reason is, there’s a chance that matrix[0][0] is changed from a non-zero value to zero by the independent variable is_col0 ! This will be falsely signify that first row also needs to be turned into zeros!

Code

void setZeros(vector<vector<int>> &matrix)
{
    int n = matrix.size();
    int m = matrix[0].size();
    bool is_col0 = false; // Marker for 0th colum

    //Mark the Rows and Columns
    for(int i=0; i<n; i++)
    {
        for(int j=0; j<m; j++)
        {
          if (matrix[i][j] == 0) {
            // Mark ith row
            matrix[i][0] = 0;

            // Mark jth column with care!
            if (j != 0) // any other column than 0th
              matrix[0][j] = 0;
            else
              is_col0 = true;
          }
        }
    }
    //Change the matrix from [1,1]=>[n-1,m-1]
    for(int i=1; i<n; i++)
    {
        for(int j=1; j<m; j++)
        {
            if(matrix[i][0] == 0 || matrix[0][j] == 0)
                matrix[i][j] = 0;
        }
    }

    //Change 0th row first,
    //matrix[0][0] is 0th row's flag
    if(matrix[0][0] == 0)
        for(int j=0; j<m; j++)
            matrix[0][j] = 0;

    //Change 0th column 
    if(is_col0)
        for(int i=0; i<n; i++)
            matrix[i][0]=0;

}

Complexity Analysis

Time: $O (m * n)$
Space: $O (1)$ Finally 🥺!

Participating in Striver's SDE Sheet Challenge

Kathan Vakharia — Sun, 04 Jun 2023 17:05:06 +0000

Alright then, Welcome Back Everyone!

As my placements' are nearing, I am starting Striver's SDE Sheet Challenge.

I'm thrilled to share that I'm taking on the demanding challenge of tackling around 180 data structures and algorithms questions. Although it won't be easy, I'm determined to succeed and grasp as much knowledge as possible throughout this journey.

My strategy for this challenge is to produce a blog post for every question I solve. These blog posts will serve as a tool to chronicle my progress and share my approach with others experiencing similar obstacles.

By breaking down each question and outlining my thought process, I'll cement my comprehension of the material and assist others who may be grappling with the same concepts.

I'm eager to observe where this challenge takes me, and my blog posts will be a valuable resource for those interested in expanding their knowledge of data structures and algorithms.

Stay tuned for updates on my progress and my first blog post!

Operating Systems: Process Control Blocks (PCB)

Kathan Vakharia — Sat, 25 Sep 2021 05:46:48 +0000

💡 I assume, you have read the previous two articles of this series before you start because I have used some of the jargon I explained in them frequently.

For sake of simplicity, assume we have only 1 CPU in a multiprogramming( preemptive or non-preemptive doesn't matter ) environment.

Whenever I use the term memory, I mean main memory or RAM until unless specified.

Need for PCB

In the previous article, we saw a program is a passive entity while a process is an active entity. Simply putting, the process is your program in execution.

It's the job of OS to dynamically assign CPU to the process which requires it because processes don't need CPU all the time, a good example might be when they go for I/O.

The question is how do you(as an OS) identify which process is which? I mean to say, there are dozens of processes that can exist at the same time in your system. For example, there can be an MS-Word process, pdf reader process, the browser process, and of course, the background processes all existing at the same time. Moreover, sometimes a process needs to be pulled out of the main memory for some other important process say, the task manager process in windows.

This is the reason, we need an identification card for every process that is created. And that identification card is what we call a Process Control Block(PCB).

💡 Commonly, PCB is also referred to as Context (of a process)

What is a PCB?

Whenever a process is created, OS also creates a data structure(a record) that contains important information about a process. This is called PCB.

Every process that comes into existence has a corresponding context or PCB associated with it. These PCBs are stored in the memory reserved for the operating system.

You can think of it as a dictionary having various keys(attribute or information name) and values(the information itself!).

Important Attributes or fields in a PCB

Process ID: A unique identification number for every process.
Program Counter: Address of the next instruction that is to be executed.
Process State: It contains the current state of the process. A process goes under various states like ready, running, wait, etc. throughout its execution. (Topic for next post)
Priority: A number specifying the importance of this process. (I will come to this when we discuss scheduling algorithms)
General Purpose Registers: It contains information about CPU registers used by the process.
- When a process is executing, data about it is stored in these so-called registers. When a process is preempted by OS to schedule some other process, this new process will override the old data present in these registers.
- Thus when our old process is scheduled again, we need its register information.
List of open files: It is self-explanatory; contains information about files that are opened by this process.
List of open devices: Again self-explanatory; contains information about opened devices say, printer.

And the list goes on...
I think you should appreciate the fact that OS exists otherwise just imagine doing process management manually!!

How are PCBs stored

These PCBs are organized in the form of LinkedList in the memory.

Summary

PCBs are important data structures created by OS for controlling the execution of a process.
Every process has a corresponding PCB associated with it.
Also known as Context.
Created in memory reserved for the operating system.

How do you guys handle the feeling "to be the BEST"?!

Kathan Vakharia — Sat, 18 Sep 2021 20:02:07 +0000

Let's be honest we all have had a longing to be the best among our peers at some point of time in our lives!

From what I have experienced over the years is the actions that follow after this feeling just drain my mind and body. And the irony is, it doesn't make you more productive too.

One solution to such feeling that I have adopted is "AFFIRMATIONS", positive ones of course :) I keep myself reminding the fact, "Life's rule is SIMPLE(NOT easy): Be the number 1 to yourself!"

Meditating every day helps too🧘‍♂️
I am curious to know what strategies, you guys apply?

PS: Some of you might say why don't you post this on QUORA instead! but as I am an aspiring DEV, why NOT here only ;)

Python 3.9 Features for Noobs

Kathan Vakharia — Sun, 12 Sep 2021 18:51:19 +0000

In this post, I will discuss some of the interesting features added in python 3.9!

The Problem: Merging two dictionaries

Prior to python 3.9, there were mainly two ways to merge or combine two dictionaries in python,

dict1 = {"name": "Salman", "age": "NA"}
dict2 = {"crimes": "lol", "career_destroyed": "uncountable"}

# Way1 : using update method
dict1.update(dict2)
print("dict1 =>", dict1)

# Way2: using ugly ** unpacking
new_dict = {**dict1, **dict2}
print("new_dict=>", new_dict)

"""OUPUT
dict1 => {'name': 'Salman', 'age': 'NA', 
'crimes': 'lol', 'career_destroyed': 'uncountable'}
new_dict=> {'name': 'Salman', 'age': 'NA',
'crimes': 'lol', 'career_destroyed': 'uncountable'}

"""

But using these methods, have drawbacks.

Why `update` is not efficient ?

d1.update(d2) modifies d1 in-place i.e changes the content of d1 dictionary.

But the problem is, it is using a temporary variable internally to update d1 dict. This is very inefficient because consider a case when you want to merge two dictionaries containing thousands of key-value pair, It is a brutal waste of memory and CPU!

😛 Then why don't we use ** , because it is not readable and ugly!

Solution : Addition of Union Operators

📃 https://www.python.org/dev/peps/pep-0584/

Let's see how python3.9 solved the issue,

Introducing merge operator `|`

The merge operator , "|" will return a new dict consisting of the left operand merged with the right operand, each of which must be a dict.

This operation has a fancy name : Dict Union

update operator `|=`

This operator performs an inplace merge similar to update method but it doesn't waste memory by using a temporary variable!

Fancy name : Augmented assignment

The Problem: How to remove sub-strings from start or end in a `str` ?

Prior to python3.9, you would do something like this,

# removing prefix or suffix prior to python 3.9
def remove_prefix(inp_str: str, pref: str) -> str:
    """
    This function deletes "pref" from the 
    beginning if it is present otherwise
    returns the original "inp_str"
    """
    if inp_str.startswith(pref):
        return inp_str[len(pref):]
    return inp_str

def remove_suffix(inp_str: str, suff: str) -> str:
    """
    This function deletes "suff" from the 
    end if it is present otherwise
    returns the original "inp_str"
    """
    if inp_str.endswith(suff):
        return inp_str[:-len(suff)]
    return inp_str

"""OUTPUT
>>> remove_suffix("Kathan", "an")
'Kath'
>>> remove_suffix("Kathan", "lol")
'Kathan'
>>> remove_prefix("Kathan","Ka")
'than'
>>> remove_prefix("Kathan","haha")
'Kathan'
"""

Isn't it too much, that we need to define functions for such a simple task? Ofcourse you can create a one-liner using lambda but what if you want a cleaner solution?

Solution : String methods to remove prefixes and suffixes

📃 https://www.python.org/dev/peps/pep-0616/

To solve this issue, 2 new methods were added.

`removeprefix` method

This method has implemented the prior discussed functionality of removing prefix for us so that we don't need to define our own function or lambda whatever.

`removesuffix` method

This method has implemented the prior discussed functionality of removing suffix for us so that we don't need to define our own function.

🎁 Bonus : Improved Math Module

📃 https://docs.python.org/3/whatsnew/3.9.html#math

`math.gcd()` function

Prior to python 3.9, this function only accepted two arguments and returned their gcd.

But quite often we need to find gcd of more than two numbers. GOOD NEWS! In python 3.9 you can add as many arguments you want into this function.

Here's the error by the way, you used to get prior to python 3.9

Using improved `math.gcd` function

The new `math.lcm()` function

Prior to python 3.9 there was no specifc function to calculate l.c.m.

Developers though had a quirky workaround for finding l.c.m,

But if you ain't a math geek, you will be confused by the function 😓, So there was a need for l.c.m function!

NEW `math.lcm()` function

That's it for this post :) Hope you enjoyed it. Check python 3.9 docs for lots of more fun stuff!

📚 Further Read: https://docs.python.org/3/whatsnew/3.9.html#what-s-new-in-python-3-9

Linked List Questions: Detect a Cycle - Set or Hashtable Approach

Kathan Vakharia — Tue, 07 Sep 2021 04:33:17 +0000

Video Explanation

Note: In the youtube video above, I have explained 2 approaches. In this post, I'll explain the first one i.e. first 8 mins of the video.

If you are more into reading, continue with the blog. I would still suggest you at least download the annotations that I did in the video :)

The Question

https://leetcode.com/problems/linked-list-cycle/

Given head, the head of a linked list, determine if the linked list has a cycle in it.

There is a cycle in a linked list if there is some node in the list that can be reached again by continuously following the next pointer.

Return true if there is a cycle in the linked list. Otherwise, return false.

💡 Give yourself at least 15-20 mins to figure out the solution :)

Explanation

The idea here is to traverse the list, and while doing that store the nodes in a set. If there's a cycle present, we'll try to insert a node(the starting point of cycle) for the second time, and as a set cannot have duplicate values, we can happily stop the algorithm by saying, YES there's a cycle in list. On the contrary, if a cycle is not present, we'll reach the end of the list and stop the algorithm by saying NO there's no cycle in the list.

Here's the pseudo code,

ListNode Node = head
Set s
while(Node != NULL)
    if(s.contains(Node)) // a node is encountered second time
        return true 
    else
        s.insert(Node)
        Node = Node.next
//if cycle was not found ie. 'if' condition was never met
return false

🗒 We are creating a set of node's addresses here NOT the node's values, Why? because node's addresses are unique in the list and values are not. For Example, 1→2→3→3→NULL doesn't contain a cycle but if we go by storing values in the set, the algorithm will say it does contain a cycle.

Why `set`? (IMPORTANT)

Problem-solving is not just about solving questions, it is also about deciding proper data structure. Some of you may have this question, why did we use set here and not any other data structure?

Our need here is to perform two operations: store and lookup(read) from our data structure in every iteration and as a set is implemented as hashtable in programming languages, we can do O(1) insertion as well as lookup. So although you can use any data structure of your choice, set a.k.a hashtable is the best choice!

If you still have any doubts, you can refer the video explanation :)

C++ Code

Definition of Linked List

//Definition for singly-linked list.
struct ListNode
{
    int val;
    ListNode *next;
    ListNode() : val(0), next(nullptr) {}
    ListNode(int x) : val(x), next(nullptr) {}
    ListNode(int x, ListNode *next) : val(x), next(next) {}
};

Solution

/* A note about 'count(Key)'
*Searches the container for elements whose value is k and returns 
*  the number of elements found
*Because unordered_set containers do not allow for duplicate keys,
*   this means that the function returns 1 if an element with 
*   that value exists in the container, and zero otherwise.
*/
class Solution
{
public:
    bool hasCycle(ListNode *head)
    {

        unordered_set<ListNode *> nodes_seen;

        while (head != nullptr)
        {
            if (nodes_seen.count(head) > 0)
            {
                return true;
            }

            nodes_seen.insert(head);
            head = head->next;
        }
        return false;
    }
};

Complexity Analysis

N: Length of Linked List

Time Complexity: O(N)

We are traversing the entire list and at every iteration, constant-time operations are done. ( and one more time if a cycle exists but asymptotically, it's still O(N) )

Space Complexity: O(N)

We are storing every node exactly once.

Computer Networks: A humble Introduction

Kathan Vakharia — Wed, 01 Sep 2021 06:26:22 +0000

📡Disclaimer: A lot of concepts in this subject are interlinked, so it is completely okay to not understand every bit of jargon thrown at you in this post. The aim is to get the big picture overview.

A textbook definition 📚

A computer network is a group of computers that use a set of common communication protocols over digital interconnection to share resources located on or provided by network nodes.

Of course, you are bamboozled by the definition 👀🥴 Let me break down the terminology,

protocol - rules that are needed to be followed while communication/sharing of resources.
digital - meaning data/resources/message is transferred in the form of 0s and 1s.
network nodes - various devices that make up the network, for eg: your computer is a node as it is connected to the Internet( a network of networks! ). It is like an endpoint or redistribution point of communication.

This all might sound boring so let's understand the working of a real computer network at a high level,

How does a simple computer network work?

Let's say you are in some network. (most probably your SIM operator's or wifi's network ).

Your computer is host1 and it has a chrome( browser ) process running inside it.

Say this process wants to go to GOOGLE. So we typed www.google.com in the search bar and pressed enter.

Our modus operandi would look something like this,

Reach google's network - a network somewhere in the US in which google server (host2) is located.
Then after reaching that network in the US, we need to reach host2 - the server itself.
And finally, we'll need to reach the process in host2 which returns google.com's web page.

So, we aim is to get Network ID - to reach destination network, Host ID - to reach destination host and port number - to reach destination process

We don't need to worry about port no. because for some standard services like web service, it is fixed.( 80 for HTTP, 21 for FTP ). Thus for most well-known services, they are already defined.

And to get NID and HID, we need to convert the domain name into a special type of number: Internet Protocol Address short for IP address because IP address contains the two parts that we need, NID and HID. This conversion is done by the DNS-Domain Name System/Service provided by your ISP.

In the next post, we shall discuss more about these so called IP addresses :)

Python Collections: Hackerrank Question on Counter

Kathan Vakharia — Thu, 26 Aug 2021 05:49:09 +0000

The Question

https://www.hackerrank.com/challenges/word-order/problem

You are given n words. Some words may repeat. For each word, output its number of occurrences. The output order should correspond with the input order of appearance of the word.

The Approach

store the words as they come in the Counter.
print them.

🧾 I hope you remember, Counter after python 3.7 internally maintains insertion order.

Code

from collections import Counter

words = list()

#n -> no of words
n = int(input())
for _ in range(n):
    words.append(input())

c =Counter(words)

print(len(c))
print(*c.values())

Pickling and Unpickling in Python🥒

Kathan Vakharia — Fri, 20 Aug 2021 12:38:58 +0000

What is pickling?

In Layman's terms, Pickling is a process to convert your python objects into a file.

Technically speaking, it is a way to convert your well-known python objects like lists, sets, tuples, dictionaries, strings, pandas dataframes,... to a character stream. And that character stream contains all the information required to reconstruct that python object in another script.

❗Note Pickling ≠ Compression → They both are completely different!

For all those programming nerds 🤓 out there, The process of converting an object to a file is also known as Serialization or Marshalling or Flattening.

Retrieving that object back from the file is known as DeSerialization or Unmarshalling or Unflattening.

Python provides the pickle module for performing serialization/deserialization.

Let's say you want to pickle a dictionary into a file,

First of all, we need to import pickle ,



import pickle
#A Sacred Dictionary 😌
sacred_dict = {"name":"Gaitonde", "location":"Chand 🌙" ,
              "side-kick":"Bunty" }

Let's see how to use it.
Here are the simple steps,

Open/Create the file in which you want to store this dictionary.
Call pickle.dump() by passing the dictionary and file object.



"""
w  => Write mode
b  => Binary mode
wb => Write in binary mode
"""
with open("sacred.pkl", "wb") as f:
        pickle.dump(sacred_dict, f)

On executing the last snippet "sacred.pkl" file will be created if not present which then will be filled with sacred_dict in form of the character stream.
It will be placed in the current working directory. You can also pass the exact file path if you want it to be stored somewhere else!

That's it, You have stored your dictionary in a file! Easy Peasy 😁

Now Let's see how to unpickle or retreive that dictionary back.

The .pkl extension is just a convention that helps us identify it as a pickle file.

To retrieve the object back, we have to use the pickle.load() method passing the file object of the pickled file,



"""

r  => Read mode

b  => Binary mode

rb => Read in Binary mode

"""

with open("sacred.pkl", "rb") as f:

        retreived_dict = pickle.load(f)

#Let's print retreived_dict to confirm 

print(retreived_dict)

#Output

  
  
  {'name': 'Gaitonde', 'location': 'Chand 🌙', 'side-kick': 'Bunty'}

Important Points about while Pickling and Unpickling

It is protocol specific to python, don't try to unpickle a file pickled in python in some other programming language. Thus, cross-language compatibility is not guaranteed.
Moreover, Unpickling a file that was pickled in a different version of Python may not always work properly, so you have to make sure that you're using the same version and perform an update if necessary.
The pickle module is not secure. Only unpickle data you trust.

That doesn't mean, you should not use pickle module. Just make sure you trust the source of that pickle file.

Database Management System: Data Models

Kathan Vakharia — Sat, 14 Aug 2021 05:19:53 +0000

The ONLY Theory You Need 📚

Data Model is a collection of concepts (fundamental building blocks or general notions) that can be used to describe the structure of a database. Thus, it provides necessary means(ways) to achieve data abstraction (easy to understand for different classes of peoples: naive users, query executors, etc.)

The structure of a database implies data types, relationships, and constraints(restrictions) that apply to data that is stored.

🗯 In simple words, a data model helps us represent data using simple concepts( say objects, attributes, tables, etc.) so that the intended audience can work on it.

Types of data models

Depending on the audience, we may need a different level of abstractions. Let me give you a real-world scenario,

Say you are hired as a database designer for your nearest shopping mall. Now you are going to perform requirement analysis to determine the structure of the database. After all the hardship, you will be needed to explain your database to the manager of the mall right? To him, you cannot talk about how SQL works, neither you can talk about how the data is stored physically! He will be flabbergasted.

⛑ To avoid the above situation, a better thing would be to explain to him in form of some diagrams/pictures so that he can understand and provide feedback for further iterations of the design.

Depending on the type of the audience, we can model the data into 3 different ways,

Hight Level or Conceptual Model
- The highest level of abstraction is provided.
- Used for modeling data for naive users.
- we use diagrams or visuals to explain our database.
- Example: Entity-Relationship(ER) model.
Representational/Implementation/Logical Model
- Less abstraction compared to Conceptual Model.
- To execute queries, we need to understand this model.
- Intended for programmers who are query executors.
- Example: Relational Model, Object-Oriented Model.
Physical Model
- The lowest level of abstraction.
- To understand how the data is stored in the memory, we need to understand this model.
- Intended for computer specialists as it talks about low-level details.

DEV Community: Kathan Vakharia

Rotate Image - LeetCode

Problem Description

Observation 🔎

Naive Approach

Code

Complexity Analysis

Using Matrix Operations

Code

Complexity Analysis

Next Permutation - O(n) Solution

Problem Description

Brute Force and STL Approach

Optimal Approach

Code

Complexity Analysis

Set Matrix Zeroes - Leetcode

Problem Description

Using a New Matrix

Code

Complexity Analysis

Space Improved Solution

Code

Complexity Analysis

Optimal Solution

Code

Complexity Analysis

Participating in Striver's SDE Sheet Challenge

Operating Systems: Process Control Blocks (PCB)

Need for PCB

What is a PCB?

Important Attributes or fields in a PCB

How are PCBs stored

Summary

How do you guys handle the feeling "to be the BEST"?!

Python 3.9 Features for Noobs

The Problem: Merging two dictionaries

Why update is not efficient ?

Solution : Addition of Union Operators

Introducing merge operator |

update operator |=

The Problem: How to remove sub-strings from start or end in a str ?

Solution : String methods to remove prefixes and suffixes

removeprefix method

removesuffix method

🎁 Bonus : Improved Math Module

math.gcd() function

Using improved math.gcd function

The new math.lcm() function

NEW math.lcm() function

Linked List Questions: Detect a Cycle - Set or Hashtable Approach

Video Explanation

The Question

Explanation

Why set? (IMPORTANT)

C++ Code

Definition of Linked List

Solution

Complexity Analysis

Time Complexity: O(N)

Space Complexity: O(N)

Computer Networks: A humble Introduction

A textbook definition 📚

How does a simple computer network work?

Python Collections: Hackerrank Question on Counter

The Question

The Approach

Code

Pickling and Unpickling in Python🥒

What is pickling?

{'name': 'Gaitonde', 'location': 'Chand 🌙', 'side-kick': 'Bunty'}

Important Points about while Pickling and Unpickling

Database Management System: Data Models

The ONLY Theory You Need 📚

Types of data models

Why `update` is not efficient ?

Introducing merge operator `|`

update operator `|=`

The Problem: How to remove sub-strings from start or end in a `str` ?

`removeprefix` method

`removesuffix` method

`math.gcd()` function

Using improved `math.gcd` function

The new `math.lcm()` function

NEW `math.lcm()` function

Why `set`? (IMPORTANT)