DEV Community: Akshat Sharma

Day 7 of SQL Series || Keys

Akshat Sharma — Wed, 11 Dec 2024 14:35:28 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog we have discussed about ALTER command and its use cases, Order By and NULL Values. In this blog we are going to discuss about Keys and Joins in SQL.

So let's get started 🔥

DESC command in SQL

To describe the structure of table in SQL we use DESCRIBE or DESC(both are the same) commands.
Let's suppose we have a users table that contains the id, name, email and age of any user. Here's how we have made it -:

So you can see that I have applied a primary key constraint on Id field. We will see what primary key is in a short time.
Now to describe the structure of table we will use following command -:

desc users

So this is the output generated. Here we have information about every field in table. We have information about datatype, constraint, initial values, Null values and extra information.
This is important when we are working with multiple tables and we want to look into structure of each table.

Keys in SQL

In SQL, keys are essential constraints used to uniquely identify records in a table and establish relationships between tables. They ensure data integrity and prevent duplicate or invalid entries.

Primary Key

The PRIMARY KEY constraint uniquely identifies each record in a table. Primary keys must contain UNIQUE values, and cannot contain NULL values.

Suppose we have a Student table that contains id, name and age of students in a class. Now here each student must have a unique id and each student must have a valid id. So we will apply a Primary Key constraint to id field. This is how we can do it -:

After adding some data to this table, this is how our table will look like -:

Now let's try to add another student with id 1.

We will get an error.

Each table can have atmost 1 primary key.
So let's try to add an column to our table with primary key constraint.

We can composite multiple columns to create one Primary Key.
You know that Sql doesn't allow to make multiple primary keys but what if we are required to apply primary key constraint on more than one column. In this case we can combine the columns and apply primary key constraint on this composition.
Let's create students table again and this time we will apply primary key on both id and name column.

So here we have defined a composition of (id,name) as student and applied primary key on that.

This is how our table looks like initially, now let's try to add (1,"John",7) to this table.

But let's try to add (5,"John",8) to this table-:

So this data is added to table. Why?
Because here the primary key constraint is applied to combination of (id,name) and we are adding distinct value of this composition.
Note that this composition of keys is called Composite Key.

Drop a Primary Key
So to drop a primary key this is how we can do it-:

The syntax depends on the type of DBMS you are working with, above is used for MySql.

Unique Key

Unique key ensures all values in a column (or a set of columns) are unique. Unlike the primary key, it allows one NULL value.
So recreating students and setting constraint of id field as unique key.

This is our table. Now let's add data to only name and age column.

A PRIMARY KEY constraint automatically has a UNIQUE constraint.
However, you can have many UNIQUE constraints per table, but only one PRIMARY KEY constraint per table.

Candidate Key

A column (or a set of columns) that can uniquely identify each record in a table. A table can have multiple candidate keys, but one is chosen as the Primary Key.

Here both Email and EmployeeId can be candidate keys because both have to be unique for every employee.

Alternate Key

Any candidate key that is not chosen as the primary key is alternate key. In above example Email is alternate key.

Super Key

A superset of candidate keys that can uniquely identify each record in a table. It may include extra columns in addition to the candidate key. In the Employees table, both EmployeeID and EmployeeID, Name are super keys.

Foreign Key

A FOREIGN KEY is a field (or collection of fields) in one table, that refers to the PRIMARY KEY in another table. The table with the foreign key is called the child table, and the table with the primary key is called the referenced or parent table. This is basically used to create a link between two tables.

Here, DepartmentID in the Employees table is a foreign key referencing the Departments table.

The FOREIGN KEY constraint prevents invalid data from being inserted into the foreign key column, because it has to be one of the values contained in the parent table.

So these were Keys in SQL.
In the next blog we will see joins.

I hope you liked my blog. Please leave some ❤ and don't forget to follow me.
Also have you checked my Instagram page where I upload necessary resources for software engineers.
If not check it out here -:
👉 Instagram: https://www.instagram.com/fluxx_96/
👉 YouTube: https://www.youtube.com/@Fluxx-n4q/shorts

Thankyou 💙

Day 6 of SQL Series || Alter Table, Order By, NULL Values

Akshat Sharma — Tue, 10 Dec 2024 16:51:19 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog we have discussed about SQL operators ,wildcards and aggragate functions. In this blog we are going to see ALTER command and its use cases, Order By and NULL Values.

So let's get started 🔥

ALTER Command in SQL

The ALTER TABLE statement is used to add, delete, or modify columns in an existing table. It is a DDL command.

Use case 1 -:

Add a column in table

Suppose we have table that contains record of Students, their Name, Roll_no and IQ. Here is the table -:

Now here we need to add one more column to table and i.e. Grade column. Here's how we can do it -:

So initially the column will contain NULL values as we have not specified any default value here.

Now the important thing is how can we add data into this as per our existing data?
So this is a tricky part here we can either introduce a formula and assign grades to each student as per that formula.

So here Update is used to update data in table then we have used Set command to set the value of Grade column according to different Cases. It works more like a Switch statement whenever it encounters a valid case then that value is of Grade is set.

But what if you have enormous data and each column has a unique entry in that case we automate the process using external scripts or we use joins.

Use case 2 -:

Drop a column in table

Now let's drop Grades column from our table.

Note that using the DROP statement, the objects are permanently deleted or lost from a database, and they cannot be rolled back.

Use Case 3 -:

Rename a column in table

Let's remane Roll_no column and change it to "Id".

Order By Statement in SQL

The ORDER BY keyword is used to sort the result-set in ascending or descending order.

We can sort our Student table based on IQ of students (ascending order)-:

Here "ASC" refers ascending order.

For descending order we will simply use "DESC".

We can also order by multiple columns. For example we sort above table both on the basis of Id and IQ. So this is how we can do it.

NULL Values in SQL

An empty field in SQL which is not being explicitly initialized is set to NULL. As you have seen above when we added "Grade" column to our table, it was empty initially.

Is Null operator

The IS NULL operator is used to test for empty values (NULL values).

Is Not Null operator

The IS NOT NULL operator is used to test for non-empty values (NOT NULL values).

So these were Alter command, Order By and Null values in SQL.
In the next blog we will see keys and joins.

Thankyou 💙

Day 5 of SQL Series || Operators , Wildcards and Aggregate Functions

Akshat Sharma — Sat, 07 Dec 2024 13:16:07 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog we have discussed about SELECT command and different use cases. In this blog we are going to see SQL operators ,wildcards and aggragate functions.

So let's get started 🔥

SQL Operators

SQL has different types of operators such as Arithmatic, Bitwise, Comparison, Compound and Logical operators. We will see one use case of each operator.

Arithmatic Operator

These are used to perform basic arithmatics on SQL numerical data.

We have aggregator functions to find the sum of complete column.

Bitwise Operator

These are basically used to do bitwise calculations.

As bitwise representation of 3 is 011 and 5 is 101 there bitwise OR will be 111 which is 7.

Comparison Operator

These are generally used with Where keyword, they generally represents a condition in the query.
Suppose we have a table that contain Students' roll_no, name and marks.
Here is the table -:

Now in this table we need to find the record of all those students whose marks is greater than or equal to 90.
So this is how we can do this -:

So here we have applied condition on Marks column and displayed the data of all those students whose Marks>=90.

Compound Operator

These are shorthand notations used to simplify expressions that update a column's value by performing an operation and then assigning the result back to that column.

This query will update Student table and increase Marks of each student by 2. We can use this operation on applying condition too for eg marks of only those students should be increased whose roll_no is 5.

Note -: Compound operators are not supported in all SQL dialects. For example, they are widely used in T-SQL (SQL Server) but may not be supported in MySQL or Oracle.

Logical Operator

Wildcards

A wildcard character is used to substitute one or more characters in a string.
Wildcard characters are used with the LIKE operator. The LIKE operator is used in a WHERE clause to search for a specified pattern in a column.

Wildcard Characters

Not supported in PostgreSQL and MySQL databases. ** Supported only in Oracle databases.

Suppose we need to display all the students whose name starts with 'J. Here's how we can do it-:

Wildcards in SQL uses Regular Expression Matching or Regex behind the scenes.

Aggregator Functions

An aggregate function is a function that performs a calculation on a set of values, and returns a single value.

The most commonly used SQL aggregate functions are:

MIN() - returns the smallest value within the selected column
MAX() - returns the largest value within the selected column
COUNT() - returns the number of rows in a set
SUM() - returns the total sum of a numerical column
AVG() - returns the average value of a numerical column

All of the above functions (except Count()) ignores Null values.
Suppose we need to find average marks of all students. This is how we can do it-:

Group By

The GROUP BY clause in SQL is used to group rows with the same values in specified columns into aggregated data. It is often used in conjunction with aggregate functions such as COUNT(), SUM(), AVG(), MAX(), and MIN() to perform calculations on each group.

So these were SQL operators, wildcard and aggregating functions.
In the next blog we will see alter table and its use cases.

Thankyou 💙

Day 4 of SQL Series || SELECT Statement Use cases

Akshat Sharma — Thu, 05 Dec 2024 16:31:12 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog we have discussed about DML (Data Manipulation Language) commands. In this blog we are going to see some of the basic commands of SQL. We will be discussing about SELECT command and different use cases in this blog.

So let's get started 🔥

SELECT Statement

The SELECT statement is used to select data from the database or more specifically table.
To understand this in a more better way we are going to use our Student table from last blog. Here is the table -:

Use Case 1

Selecting all rows of table -:

So here Select is used to select data '*' refers to all the rows or complete data.
Here is output -:

I can't able to show complete output here but you will get it when you try it on your own.

Use Case 2

Selecting specific column from table -:

This query will display complete data of Name column.

Use Case 3

Select distinct items from table -:
For this I'll add some duplicate rows in table. So our table will look like -:

Now we will select only distinct rows here.

So here we are using distinct to select distinct rows and '*' for selecting all columns. We can select distinct values from a particular column too for this you just need to replace * from column name.

Use Case 4

Selecting all the students of Class 5B -:

In the above query where is used to filter records based on specified condition. Here we are selecting all the students of Class 5B.
Here is the output -:

We can also select distinct entries all we need to use is Distinct keyword here.

Use Case 5

Selecting all the students whose Roll_no is between 12 and 21-:

Here we have applied a condition on Roll_no and based on that condition output is generated.

You can apply different operations here for example selecting students with roll_no greater than a particular value or selecting students having roll_no equal to particular value.

Use Case 6

Selecting all the students whose name starts with J-:

Here we have used like and 'J%'.
The like operator is used with where clause to search for a pattern in string.
% represents zero, one, or multiple characters, so here we have given the starting character of the string i.e. 'J'.

Use Case 7

Selecting only first 3 records from table -:

Here we have used limit keyword to show top 3 rows this is a MySQL based syntax different management systems have different syntax like in Oracle based system we can do it by just applying a condition on ROWNUM or you can use FETCH FIRST.

So these were some basic Select command usecases. This was just an introduction we will see some good use cases in upcoming blogs.
In the next blog we will see operators and wildcards and its use cases.

Thankyou 💙

Day 3 of SQL Series || Basic Commands

Akshat Sharma — Mon, 02 Dec 2024 12:01:13 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog we have discussed about DDL (Data Definition Language) commands. In this blog we are going to see some of the basic commands of SQL. We will be discussing DML (Data Manipulation Language) commands in this blog.

So let's get started 🔥

Data Manipulation Language Commands

Data Manipulation Language (DML) Commands are used to manipulate data present in the database.
Some of the commonly used DML commands are -:

INSERT
UPDATE
DELETE
LOCK
CALL
EXPLAIN PLAIN

In this blog we will be focusing on the above three commands, we will look the last three commands in upcoming blog.

INSERT Command

In the last blog we have seen how to create a table let me explain you again with an example -:

So here we have created a table named Student that contains three variables namely Name (a string of atmost 50 characters), Roll_no (an integer value) and Class (a string of atmost 10 characters).

We will understand table schema in the next blog for now we will try to insert some data in this table.

So we have added three rows in our table. Now our table looks like this -:

So you may have understood that INSERT command is used to insert data in table. It allows for the insertion of data either by specifying the column names along with the values or by providing values for all columns in the table.
So this is one usecase here now suppose we need to insert values of only first two columns how are we going to do that. Let's see-:

So here we have specified the column names in which we want to insert values. Let's have a look on our table now -:

We will see some advanced use cases of this command in coming blogs. For now let's keep it simple.

UPDATE Command

Now suppose we need to update the existing data in the table.
Let's suppose in the above table we need to update the row with Name="Raj". So here's how we will do it-:

So here we have updated the table Student. For this we have selected the row with Roll_no 30 and then we set the Name as "Anand".

This is one of the simplest use case of UPDATE command. For advanced use cases we need to understand more commands.

DELETE Command

The DELETE command is used to remove one or more rows from table depending on the condition we imply. Unlike the DROP statement, which removes the entire table, the DELETE statement removes data (rows) from the table retaining only the table structure, constraints, and schema.

In the above table we will remove the last two rows. This is how we will do it -:

As we have not provided any value in Class column in last two rows that is why we have used the condition Class is NULL as by default CLASS column is initialized by NULL.

So these were three basic DML commands. This was just an introduction we will see some good use cases in upcoming blogs.
In the next blog we will see SELECT statement and its use cases.

Thankyou 💙

Day 2 of SQL Series || Basic Commands

Akshat Sharma — Sat, 23 Nov 2024 11:31:28 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog we have discussed about basic introduction to SQL. In this blog we are going to see some of the basic commands of SQL. We will be discussing DDL (Data Definition Language) commands in this blog.

So let's get started 🔥

SQL Commands

Before starting our discussion I want tell you that you can practice SQL on the available online SQL compilers. I am attaching link of one here 👇

https://www.programiz.com/sql/online-compiler/

In SQL, DDL (Data Definition Language) commands are used to define, modify, and manage the structure of database objects such as tables, indexes, and schemas. Here’s a comprehensive list of all commonly used DDL commands:

CREATE
ALTER
DROP
TRUNCATE
RENAME
COMMENT
USE
SHOW

CREATE Command

The CREATE command is create new database objects such as tables, views, indexes, and databases.

Create a Database -:
Note -: The statement will throw an error when you are working on an online compiler.
Create a Table -:
Example -:

So here we have created a table named student_record that contains three type of data student's name which will be a string of atmost 100 characters, student's age which will be of integer type and student's ID which will also be a string of atmost 30 characters.

Note that duplicate column names (same name and same type) are not allowed.

SHOW Command

Used to display the metadata about database objects, such as tables or databases.

Show Database
Show Tables
Show Table Structure

This command DESCRIBE is used to see complete table structure it gives complete detail of all columns in table.

USE Command

This command is used to select a specific database to work with in a session.

COMMENT Command

It is used to add comments to database objects like tables or columns for documentation purposes.

Add a Comment to a Table
Add a Comment to a Column

ALTER Command

It is used to modify existing database objects such as tables, columns, and constraints.

Add a Column For example, Suppose we have a table that stores customers' data. Now we will add an "Email" column here.

-Modify a Column

Here we are changing data type of column.
Note that the ALTER TABLE syntax can vary depending on the SQL dialect (e.g., MySQL, PostgreSQL, SQL Server, etc.) you're using. Some may support a particular keyword some may throw error.

DROP Command

It is used to delete database objects such as tables, databases, or indexes. This operation removes the object and its data permanently.

RENAME Command

It is used to rename a database object, such as a table or a view.

TRUNCATE Command

It is used to remove all rows from a table without logging individual row deletions, resetting the table for new data. This does not affect the table structure. This means the table become empty.

So these were all DDL Commands of SQL. In the next blog we will see some DML commands and will run different queries on table.
I hope you liked my blog. Please leave some ❤ and don't forget to follow me.
Also have you checked my Instagram page where I upload necessary resources for software engineers.
If not check it out here -:
👉 Instagram: https://www.instagram.com/fluxx_96/
👉 YouTube: https://www.youtube.com/@Fluxx-n4q/shorts

Thankyou 💙

Day 1 SQL Series || Introduction to SQL

Akshat Sharma — Thu, 21 Nov 2024 10:29:51 +0000

Hey there 👋

Hope you are doing well 🙂

In the last blog as I have promised that I'll be starting a 7 days SQL series so here it is. In this blog we will discuss the basic introduction to SQL and database and tabular/relational and non relational database management systems.

So let's get started 🔥

What is Data?

Data is a collection of facts and figures or more specifically information that is gathered by observations, measurements, research or analysis.

What is Database?

Now we need something where we can store our data and can easily manipulate and retrieve it. So here comes Database in picture.

A Database is a systematically organized collection of data stored electronically in a computer system. It allows for efficient storage, manipulation, and retrieval of data as needed. Databases are managed using software called a Database Management System (DBMS).

Types of Database Management Systems

The Database Management Systems are classified into two main types -:

Relational DBMS
Non relational DBMS

Relational DBMS

Relational DBMS or RDBMS stores data in tables with rows and columns and it requires a predefined schema that defines the structure of the data (e.g., data types, constraints). It ensures data integrity and reliability through ACID -:

Atomicity: Transactions are all-or-nothing.This ensures the data operation will complete either with success or with failure.For example, a transaction will either be committed or will abort.
Consistency: Ensures data validity.If we perform any operation over the data, its value before and after the operation should be preserved. For example, the account balance before and after the transaction should be correct, i.e., it should remain conserved.
Isolation: Concurrent transactions do not interfere.There can be concurrent users for accessing data at the same time from the database. Thus, isolation between the data should remain isolated. For example, when multiple transactions occur at the same time, one transaction effects should not be visible to the other transactions in the database.
Durability: Data changes persist after transactions.It ensures that once it completes the operation and commits the data, data changes should remain permanent.

Non Relational Database Management System

Non Relational DBMS or NoSql Database does not follow the traditional table-based relational model. It is designed for flexible, unstructured, or semi-structured data.

Now that we know that what data, database, types of database and DBMS actually is, there arises a question that how exaclty the data is managed 🤔?
So to answer this question we need to understand SQL.

Introduction to SQL

SQL is a standard language for accessing and manipulating databases.
SQL stands for Structured Query Language that is used to access and manipulate Relational Database.
SQL was primarily designed for managing Relational Databases.
It was developed by IBM Computer Scientists in the 1970s.

It consists of different queries that can be used to create, insert, delete and change data.
SQL is one of the widely used languages for tabular data. Even if you are someone who aspires to be an ML engineer SQL plays a very significant role.

Features of SQL

Data Definition Language (DDL) -: SQL allows you to define the structure of a database using commands.
Data Manipulation (DML) -: SQL enables inserting, updating, deleting, and retrieving data using its commands.
Transaction Control (TCL) -: SQL supports transactions to ensure data integrity. We can easily save or undo changes in transactions.
Data Control (DCL) -: SQL includes commands to manage user permissions.
Standardized -: SQL is standardized by ANSI and ISO, ensuring compatibility across different relational database systems (e.g., MySQL, PostgreSQL, SQL Server).
Scalability -: SQL works well with databases of any size, from small projects to enterprise-level systems.
Integration with Programming -: SQL can be integrated with programming languages (e.g., Python, Java, C#) to create dynamic applications.

In conclusion SQL is basically a language used to manipulate RDBMS. Now in the next blog we will see some basic commands of SQL.
I hope you have enjoyed this blog. Please leave a ❤ and if I have missed something or you have doubts we can discuss them in comments.

Thankyou 💙

Launched a Social Page for every Software Engineer

Akshat Sharma — Wed, 20 Nov 2024 12:03:33 +0000

👋 Hello People!

I hope you're all doing well! 😊

✨ It’s been a while since I last posted here, and I truly apologize for the unexpected break. But guess what? I’m back! 🎉 And this time, I have some exciting news to share with you all.

Your support and feedback have been invaluable in my journey, and I’m incredibly grateful to this amazing community. 🙌

💡 So, where was I?

During this time, I’ve been working hard on a passion project—a social media page—and I’m thrilled to announce that it’s now LIVE! 🚀

🌟 The page is called Fluxx, and it’s a space where I share:

💻 Essential resources
🛣️ Detailed roadmaps
🎥 Short and practical tutorials

The whole idea behind Fluxx is to spread knowledge and help fellow developers by providing valuable resources and guidance.

🔗 Check it out here:
👉 Instagram: https://www.instagram.com/fluxx_96/
👉 YouTube: https://www.youtube.com/@Fluxx-n4q

✨ Please take a look, explore the content, and let me know your thoughts! I’d love to hear your feedback and suggestions to make it even better. If you find the content useful, don’t forget to follow and share it with others. It would mean the world to me! 🌍

But wait… there’s more!

🎉 Surprise Alert! 🎉

I’m launching an ultimate 7-day SQL series right here on Dev Community! 🗂️ Get ready to dive into some amazing SQL tips and tricks over the next week.

❤️ If you enjoyed this post or found it helpful, don’t forget to leave a heart and share it with your friends.

Thank you so much for your support, Dev Community! 💙 Let’s continue to grow, learn, and build together.

What I have learnt from solving 1600 Leetcode Problems 🤯|| DSA Guide

Akshat Sharma — Wed, 23 Oct 2024 08:50:40 +0000

Hey there! 👋 Hope you’re doing well 🙂
As software engineers, we know that landing an SDE role at a multinational company or a startup means one thing — mastering Data Structures and Algorithms (aka DSA) is key. And with that in mind (and maybe a little obsessed 😅), I’ve solved 1600 DSA problems! 🤯

In this blog, I’ll share how tackling this many DSA problems has impacted me and whether solving that many is really necessary.

So, let’s dive in! 🔥

My DSA Journey: Solving 1600 Problems and What I Learned Along the Way

I started my DSA journey back in 2021, during my second year of college. I gathered all the resources I could find and explored every platform where I could practice problems.

I began with basic array problems on Leetcode, tagged as “Easy.” But as I worked through them, I noticed various tags like Prefix Sum, Hash Table, Greedy, etc., and my curiosity grew! Soon, I was diving into concepts like binary search, prefix sums, and hashing, learning how to implement them based on the problem’s requirements.

But… it wasn’t as easy as it seemed. 🤯 Many problems needed slight tweaks in the concepts, and understanding the core requirement of each problem was tough. To tackle this, I started breaking down the sub-concepts, like applying Binary Search to find an answer or combining Prefix Sum with a Hash Table to solve certain subarray problems.

Still, things didn’t fully click. Every time I encountered a new twist in a problem, I got puzzled again. 😅 That’s when I realized the importance of recognizing patterns. And this was a game-changer! 🎯 I started noticing that some problems consistently required Binary Search on the answer, while others needed Prefix Sum + Hash Table combos. By recognizing and applying these patterns, I found myself ahead of the curve! 🚀

I applied the same approach to intermediate and advanced DSA concepts too. But here’s where it gets interesting — how solving DSA problems, recognizing patterns, and implementing concepts has impacted me.

Now, I’m able to tackle almost any new problem that comes my way! 💪 Sure, some problems still stump me at first, but that’s usually because I’m not yet familiar with a particular pattern or concept.

Solving this many DSA problems has given me deeper insights into how other technologies work, especially on the backend. It’s also sharpened my overall problem-solving skills since DSA is all about finding the most optimal way to solve a problem using the right data structures. And let’s be honest — big tech companies focus more on our problem-solving abilities rather than just subject matter expertise. 🧠

I know I’ve solved more problems than most would consider necessary, but once I developed the problem-solver mindset, it was like I became possessed! 😂 Every time a problem came up, my brain would go into autopilot mode, and all I could think about was how to solve it in the most optimal way.

So yes solving DSA with proper trick was truly a game changer for me 😃

Is Solving 1600 DSA Problems Really Necessary?

Now, let’s get real — do you really need to solve 1600 DSA problems to succeed? The short answer is, not necessarily. 🤔

While solving a large number of problems definitely helped me develop strong problem-solving skills and recognize patterns more quickly, it’s not about hitting a specific number. What’s most important is understanding the concepts deeply and being able to apply them effectively in different scenarios.

For some people, solving 500 well-chosen problems might be enough to build the intuition they need. For others (like me 😅), solving a higher number just reinforces that problem-solver mindset. The key is to focus on quality — understanding how and why a solution works — rather than just aiming for a high number.

At the end of the day, what truly matters is the ability to approach problems methodically and solve them optimally. Whether you do that by solving 200 or 1600 problems is up to you!

Here is my Leetcode profile link 👉https://leetcode.com/u/akshat0610/

If you found my blog interesting please leave some 💙 and don’t forget to follow me 🤗

Thankyou 💙

Top 10 System Designs || Interview Guide

Akshat Sharma — Fri, 04 Oct 2024 10:18:02 +0000

Hey There 👋

Hope you are doing well 😃

Whether you’re a fresher or an experienced software engineer, one thing is clear: cracking an SDE (Software Development Engineer) interview requires a solid understanding of System Design. In today’s tech-driven world, the ability to design complex systems and optimize them for scalability, efficiency, and reliability is a must-have skill.

This blog is your guide to mastering the key system design concepts that will not only help you ace interviews but also equip you for real-world challenges. We’ll walk you through 10 essential system designs that are frequently asked in interviews, offering you practical insights and strategies. Whether you’re just starting or looking to sharpen your expertise, these exercises will provide you with the foundation you need to confidently discuss and design large-scale systems.

Let’s dive in and start building your system design expertise!

List of 10 Important System Designs

URL Shortening Service
A Messaging Service Like WhatsApp
Instagram Feed Design
Video Streaming Platfrom like YouTube , Netflix
Ride Sharing Service like Uber
A Web Crawler like Google
An ECommerce System like Amazon
Food Delievery Service Like Swiggy, Zomato
Design Spotify
Design File Sharing System like Dropbox

This was the list of 10 important system designs. A quick tip is follow latest updates and crahses of famous systems as they are more likely to be asked. Practice as much as possible to ace a system design interview.

If you like my blog please follow me and don’t forget to leave some ❤

Thankyou 💚

864. Shortest Path to Get All Keys || Leetcode || Hard

Akshat Sharma — Wed, 25 Sep 2024 11:09:23 +0000

Hey there 👋

Hope you are doing well 😃

In this blog we are going to discuss the approach for the Leetcode problem 864.Shortest Path to Get All Keys. We are going to understand the problem statement then we will try to build solution of the problem and finally we are going to code it.

Link of problem -: https://leetcode.com/problems/shortest-path-to-get-all-keys/description/

So let’s get started 🔥

Problem Statement

You are given an m x n grid grid where:

'.' is an empty cell.
'#' is a wall.
'@' is the starting point.

Lowercase letters represent keys.
Uppercase letters represent locks.

You start at the starting point and one move consists of walking one space in one of the four cardinal directions. You cannot walk outside the grid, or walk into a wall.

If you walk over a key, you can pick it up and you cannot walk over a lock unless you have its corresponding key.

For some 1 <= k <= 6, there is exactly one lowercase and one uppercase letter of the first k letters of the English alphabet in the grid. This means that there is exactly one key for each lock, and one lock for each key; and also that the letters used to represent the keys and locks were chosen in the same order as the English alphabet.

Return the lowest number of moves to acquire all keys. If it is impossible, return -1.

Example

Example 1

Input: grid = ["@.a..","###.#","b.A.B"]
Output: 8
Explanation: Note that the goal is to obtain all the keys not to open all
the locks.

Example 2

Input: grid = ["@aa"]
Output: -1

Problem Explanation

In the problem we are given a maze 𝄜 which consists of some locks 🔒and their corresponding keys 🔑, some walls 🧱 , empty spaces ▫ and a starting point @. The walls are denoted by ‘#’ . Keys are lowercase letters (‘a’ to ‘f’) and locks are uppercase letters corresponding to keys. Empty spaces are denoted by ‘.’ and starting point is denoted by ‘@’.

Our task is to find all the keys in the minimum moves possible. We can’t go through a wall and if it not possible to collect all the keys then our answer will be -1.

Now the question is how we can take moves such that we can collect all the keys and the moves are minimum? ❓

To understand this let’s look at our Example 1 -:

Input: grid = ["@.a..","###.#","b.A.B"]
Output: 8
Explanation: Note that the goal is to obtain all the keys not to open all
the locks.

Now you can see that our guy 👨 starts from (0,0) and as per our problem he can move in four different directions up, down, left and right. We know that from (0,0) going in up and left direction is not possible 💁‍♂️ and he can’t go down as wall is there. So now he will just move in right direction. So his new position is (0,1). Now from this position again he can go in four different directions and these different paths are going to give him different answers and our concern is to get minimum out of these also he is not going to visit the cells he has come from because this can make him go round about and he will never be able to get keys.
So from (0,1) he will go to right cell (0,2), you know why 🙂.
Now you can see that he finds a key 🔑 so he will simply keep it with himself and will move forward. Again he will go to right cell i.e. (0,3). From this cell he can either go right or he can go down. If he goes to right (0,4) now he can’t go anywhere, so going right will not give any answer to us.
Let’s go down (1,3) and from here again he can go in four different directions.
So doing this again and again will surely lead to our answer.

But wait 😶, there’s a catch here it is not as easy as it seems here 🫨.

You can see that from a given cell we are going on four different cells (four directions) and each cell is giving us a different answer because each cell leads to different path. Now this is very important statement here “each cell leads to different path”. Why? 🤔

Suppose we have another grid -:
grid=["@...a",".###A","b.BCc"]

So here we have two different paths possible from (0,0) one from right and other from down. And also we can take key ‘a’ in two different ways.
One way is moving only in right direction from (0,0) and other path is ‘(0,0) -> (1,0) -> (2,0) -> (2,1) -> (2,0) -> (1,0) -> (0,0) -> (0,1) -> (0,2) -> (0,3) -> (0,4)’. Huh 😵? But we can’t trace the path we have visited before then how is this path possible 😵‍💫?

The path is possible because while returning our guy has one more thing with him and that is the ‘bth key’ and hence this makes all the difference 🤯.
Problem says to get all keys in minimum moves so following differnt paths will give us different number of moves and different number of keys.
For example following the below path will give us answer -1.

But following this path will give us 10 moves.

With each move guy’s position and keys he collected from a given path and total moves he took is associated. So this is why we are tracing back to the path which we followed earlier but this time with 1 key acquisition.

So this was complete problem explanation. Now let’s head to solution of the problem.

Solution

Now we know that the most important part of the problem is the state of each cell in path is (position,keys,steps). And our task is to find the minimum number of moves to collect all the keys.

So we can use Breadth First Search here. Why BFS?

Because BFS sees all the possible cells of a given cell first before moving to next level and this ensures shortest path possible.

We will make a queue that will contain {initial position of guy,keys he collected,total moves}. So for our example 1 the element in queue will be {0,0,0,0} (0th row, 0th column, bitmask for key, total moves).
Now you might be wondering why we have taken bitmask here? 🤔

Look at the problem carefully we have locks too of corresponding keys so using bitmask when we encounter a lock we can ensure that we have already collected the key related to that lock. So in short bitmask will help us in identifying which key we have collected so far.

So using queue we will see all the paths possible and will get answer when any one of the path gives us all the keys. 💁‍♂️

Code

Here ’n’ denotes the number of rows in grid and ‘m’ denotes the number of columns in grid. Also ‘dir’ denotes the directions we can move in.

So here I have defined a ‘vis’ vector it will keep track of visited path. Note that here we have stored position (row,col) and bitmask in visited array. We have taken size of this array as n*m*64. We have taken 64 because our bitmask can go upto 2⁶-1 as our keys are represented by 6 different letters.
Then I traversed the grid to get the starting position of guy and total number of keys. After this I have made a queue in which I pushed starting position of guy, bit mask and total moves.

`while(q.size() > 0)
{
int row = q.front()[0];
int col = q.front()[1];
int mask = q.front()[2];
int steps = q.front()[3];

 q.pop();

 int req_ans = pow(2,keys);
 if(mask == (req_ans-1)) return steps;

 for(int i = 0 ; i < dir.size() ; i++){
     int r = dir[i][0]; int c = dir[i][1];
     if(isValid(row+r,col+c) == true)
     {
          if(grid[row+r][col+c] == '.'){
               if(vis[row+r][col+c][mask] == false){
                    vis[row+r][col+c][mask] = true;
                    q.push({row+r,col+c,mask,steps+1});   
               }
          }
          else if(grid[row+r][col+c] == '#'){
               continue;
          }
          else if(grid[row+r][col+c] == '@'){
               if(vis[row+r][col+c][mask] == false){
                    vis[row+r][col+c][mask] = true;
                    q.push({row+r,col+c,mask,steps+1});   
               }
          }
          else if(grid[row+r][col+c] >= 'a' and grid[row+r][col+c] <= 'z'){
               if(vis[row+r][col+c][mask] == false){
                    vis[row+r][col+c][mask] = true;
                    int updated_mask = mask | (1 << (grid[row+r][col+c]-'a'));
                    q.push({row+r,col+c,updated_mask,steps+1});    
               }
          }
          else{
               if(vis[row+r][col+c][mask] == false){
                   char lock = (grid[row+r][col+c]);
                   char key = tolower(lock);
                   int found = (mask & (1 << (key - 'a'))); 
                   if(found > 0) q.push({row+r,col+c,mask,steps+1});   

                   vis[row+r][col+c][mask] = true;
               } 
          } 
     }
 }

}`
Here we have our code for BFS. We take the front entry of queue if this entry has all keys then we return the steps. Otherwise we go in different directions. Now going in different directions can possibly lead us to a wall, empty space, lock, key or out of grid. So we have to check each of the case. Also we need to ensure that the next state we are visiting is not seen before.

When we encounter a lock we will check our bitmask is having its key or not. If present we will push this entry in queue.
When we encounter a key we will update our mask and we will push this entry in our queue.
Note that following the steps we can visit some cells again but these cells must have different state.

You can check complete code here -: https://github.com/akshatsh0610/Data-Structures-and-Algorithms-Problems-Solution/tree/main/Leetcode%20Problems/Breadth%20First%20Search

Conclusion

Using BFS and bit manipulation we can easily solve this problem. We need to make sure the state of each path to get correct answer.

I hope you have understood it well. For more follow me and don’t forget to leave some reactions.

Thankyou 💚

Beginner's AID|| A Data Structures and Algorithms Guide || Get Interview Ready

Akshat Sharma — Sat, 21 Sep 2024 06:26:51 +0000

Hey there! 👋
Hope you’re doing great! 😃

So, you’ve probably heard a ton of people talking about cracking interviews at big companies (whether it’s an MNC or a startup), right? It takes some serious prep and dedication. And there’s this one thing that everyone seems to bring up over and over: Data Structures and Algorithms **— or, as the cool kids call it, **DSA.

DSA isn’t just another topic you can gloss over. It’s the foundation that you need to build if you want to nail those interviews and land that dream job! 🚀 But don’t worry — I’m here to guide you through the maze.

In this blog, we’re going to talk about:

How to kick off your DSA journey.
The roadmap you’ll follow.
The best platforms to practice on
Some other important stuff you should know along the way.

So, buckle up, and let’s dive into the world of DSA! 🔥

How to get started with DSA?

Before diving into the topic, it's crucial to understand what DSA actually is and why it's so important. Let me give you a quick breakdown of these two key questions!

What is DSA?
DSA is an acronym for Data Strcutures and Algorithms. It is a fundamental part of Computer Science that teaches you how to think and solve complex problems systematically. Using the right data structure and algorithm makes your program run faster, especially when working with lots of data.

Why DSA is important?
Here's why you must get a grip on DSA:

Problem Solving: Companies love to test your problem-solving skills, and DSA is the toolkit that helps you solve problems effectively.
Efficiency: Knowing DSA allows you to write code that's not just correct but also fast and scalable. This is what top companies expect from you.
Interview Cracker: Almost all tech interviews focus on DSA. So, mastering it means increasing your chances of cracking interviews at big tech companies like Google, Amazon, or startups.
Build Strong Foundations: Once you get DSA down, other advanced topics like system design, AI, or machine learning become easier to grasp.

Simply put, DSA isn't just about cracking interviews - it's about becoming a better coder! 🚀
Now that we know what it is and why it's so important, let's dive deeper into how to get started with it! 🔥
One of the first questions that pops into everyone's mind is: Which programming language should I use for DSA? 🤔

Language Choice for DSA
Honestly? You can pick any language you're comfortable with! (Just don't go thinking you can use a styling or markup language like HTML/CSS! 😆). Whether it's Java, C++, Python, Go, R, or any other programming language you're familiar with - they all work just fine for DSA. The key is to choose one that you have a good grip on so you can focus on the algorithms, not the syntax.

Resources for Studying DSA
Next question: Where can I study DSA?
Luckily, finding resources is easier than ever. With 4 out of 5 tech creators teaching DSA these days, you'll find plenty of content online. You can access:

YouTube playlists with step-by-step tutorials.
Websites offering comprehensive guides.
Courses that take you from beginner to pro.

Here are a few solid resources to get you started:

W3Schools DSA
GeeksforGeeks DSA Tutorial
Striver's A2Z DSA Course Sheet

These are great starting points for beginners looking to build a strong foundation in DSA! 🎯
With the right language and resources, you're all set to begin your journey. Let's keep moving forward! 🔥

Roadmap for DSA

So, you've chosen your programming language and gathered your resources. Now it's time to follow a well-structured roadmap to master DSA! 🎯

1. First Things First: Master the Programming Basics
Before you even think about diving into DSA, you need a solid understanding of basic programming concepts. Make sure you're comfortable with:

Operators
Input/Output
Conditionals
Loops

If these concepts aren't second nature to you, you might find yourself in big trouble! 😨 So, my advice? Study the fundamentals of programming first before jumping into DSA.

2. Start with Basic Programs and Concepts
Now that you're comfortable with the basics, it's time to get your hands dirty with some simple programs. Start with tasks like performing arithmetic operations, playing with loops, and working with conditionals. You should also learn:

Bit Manipulations
Structures and Classes
Recursion (yes, recursion can feel like a beginner's worst nightmare 💀, but trust me, you'll get the hang of it!)

Once you've nailed these, you're ready to dive deeper into the world of DSA.

3. Get Familiar with Basic Data Structures
Now comes the fun part: Data Structures! Start with the basic ones:

Arrays
Linked Lists
Stacks
Queues
Strings (an array of characters)

Understand each data structure thoroughly and solve plenty of practice problems to get comfortable with them.
Once you've got these down, it's time to learn about:

Hash Tables (Maps)
Sets
Bit Manipulations

You should also tackle some basic algorithms:

Sorting Algorithms: Bubble, Selection, Insertion, Quick Sort, Merge Sort, Heap Sort, Count Sort, Radix Sort.
Searching Algorithms: Linear Search, Binary Search.
Other Key Concepts: Prefix Sum, Sliding Window, Two-pointer technique, and Greedy algorithms.

4. Unlock the Power of Data Structures
As you dive deeper into DSA, you'll notice each data structure comes with unique concepts:

Monotonic Stacks (essential for certain problems).
Queues for implementing Breadth-First Search (BFS).
Linked Lists for designing more advanced systems.

5. Level Up: Non-Linear Data Structures
Congratulations, you've moved past the beginner stage! Now it's time to prepare for non-linear data structures - but start slow. Focus on Trees first (don't jump to Graphs just yet).

Learn about Binary Trees and Binary Search Trees.
Understand Tree Traversal Algorithms (Inorder, Preorder, Postorder).
Practice Tree Manipulations like insertions, deletions, and modifications.

6. Get Ready for Advanced Stuff: Dynamic Programming (DP) 😈
Before diving into Dynamic Programming, you need to be super comfortable with Recursion and Backtracking. These concepts are at the core of DP. Make sure to practice them as much as possible.
Here are some classic DP problems that pop up in nearly every interview:

0/1 Knapsack Problem
Longest Common Subsequence & Substring
Fibonacci Series
Jump Game (multiple variations)
Best Time to Buy and Sell Stock (multiple variations)
Stone Game (multiple variations)
Russian Dolls (a classic DP + Binary Search problem)
Matrix Chain Multiplication
Kadane's Algorithm (for maximum subarray problems)

By now, you're officially at the intermediate level in DSA! 💪 You're ready to crack those interviews.

7. Going Beyond: Advanced Data Structures & Concepts
If you've come this far, you're ready to tackle more advanced topics. These will take your DSA skills to the next level:

Graphs: Depth-First Search (DFS), Breadth-First Search (BFS), Shortest Path Algorithms (Dijkstra, Bellman-Ford).
Tries: Useful for word problems and prefix matching.
Segment Trees & Fenwick Trees: For range queries and dynamic data.
Advanced Algorithms: String Matching (KMP, Z algorithm), Union-Find, and advanced combinatorics.
Number Theory: Crucial for competitive programming, covering GCD, LCM, Modular Arithmetic, etc.

If you're looking to get into Competitive Programming, you'll need a deep understanding of number theory and advanced algorithms. But don't worry - you'll get there with time and practice!

By following this roadmap and putting in consistent effort, you're well on your way to becoming a DSA master! Whether you're aiming to crack interviews or dive into competitive programming, you're now equipped with the knowledge to level up your skills. Keep practicing, and remember: persistence is key! 🔥

Important Platforms

Now that you have a perfect roadmap. You have to make yourself aware of certain platforms where you can practice different DSA problems.

The platforms that I prefer for praticing problems are -:

These are very beginner friendly platforms and they contain problems asked by all big tech giants and advanced problems too.
There are other platforms too.

For competetive programming -:

Other important stuff

So now that you've got your resources, roadmap, and list of platforms, you're all set for your DSA journey! 🚀

A little suggestion - try practicing DSA with one or two friends. It adds a fun, competitive spark to your learning and keeps the motivation high. You'll be surprised how much faster you can improve when you're learning together and challenging each other!

And that's really all you need. You've got the tools, the plan, and the determination. Now go and crush it! 💥

I hope you find this helpful and resourceful.

Thank you and good luck on your journey! 💛