DEV Community: Garvit Khamesra

Python Cheat Sheet: The Basics

Garvit Khamesra — Sat, 30 Aug 2025 04:08:16 +0000

Python Cheat Sheet: The Basics

A quick reference for Python fundamentals, ideal for Data Science, AI, and Development learners.

Python Data Types

String

A sequence of characters stored as text.

my_string = "Hello"

Common operations:

my_string.upper()      # Convert to uppercase

len(my_string)         # Get length

my_string.find('l')    # Find index of first 'l'

my_string.replace('H', 'C')  # Replace 'H' with 'C'

Integer

Whole numbers.

my_integer = 12321

Float

Decimal numbers.

my_decimal = 3.14

Boolean

True or False values.

a = True b = False

Dictionary

Changeable collection of key-value pairs.

my_dictionary = {'banana': 1, 12: 'laptop', (0,0): 'center'}

my_dictionary['banana']      # Access value

my_dictionary.keys()         # List of keys

my_dictionary.values()       # List of values

Tuple

Unchangeable collection of objects.

tup = (1, 3.12, False, "Hi")

List

Changeable collection of objects.

my_collection = [1, 1, 3.12, False, "Hi"]

len(my_collection)           # Length

my_collection.extend(["More", "Items"])  # Add multiple items

my_collection.append("Single")           # Add single item

del(my_collection[2])        # Delete item at index 2

clone = my_collection[:]     # Clone list

my_collection_3 = my_collection + ["a", "b", "c"]  # Concatenate

sum([1,2,3,4.5])             # Sum numbers

item in my_collection        # Check existence

item not in my_collection    # Check non-existence

Set

Unordered collection of unique objects.

a = {100, 3.12, False, "Bye"}

b = {100, 3.12, "Welcome"}

my_set = set([1,1,2,3])      # Convert list to set

a.add(4)                     # Add item

a.remove("Bye")              # Remove item

a.difference(b)              # Set difference

a.intersection(b)            # Set intersection

a.union(b)                   # Set union

a.issubset(b)                # Subset check

a.issuperset(b)              # Superset check

Indexing and Slicing

Access elements by position:

my_string[0] my_collection[1] my_tup[2]

Access a range of elements:

my_string[1:4] my_collection[0:3] my_tup[1:3]

Operators

Comparison Operators

a == b : Equal
a < b : Less Than
a > b : Greater Than
a >= b : Greater Than or Equal
a <= b : Less Than or Equal
a != b : Not Equal

Arithmetic Operators

+ : Addition
- : Subtraction
* : Multiplication
/ : Division
// : Integer Division

Conditional Operators

a and b : True if both are true
a or b : True if either is true
not a : Opposite of a

Control Flow

Loops

for x in range(5):           # Loop 5 times

    print(x)

for item in iterable:        # Loop through iterable

    print(item)

while condition:             # Loop while condition is true

    # code

Conditional Statements

if condition1:

    # code

elif condition2:

    # code

else:

    # code

Try/Except

try:

    # code

except ExceptionType:

    # handle error

else:

    # code if no error

Common Error Types

IndexError : Index out of range
NameError : Variable name not found
SyntaxError : Code syntax error
ZeroDivisionError : Division by zero

Range

Create sequences of numbers:

range(5) # 0,1,2,3,4 range(2, 10, 2) # 2,4,6,8

Webscraping

Using BeautifulSoup:

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, 'html5lib')

soup.prettify()

soup.find('tag')

soup.find_all('tag')

Requests

Using the requests library:

import requests

response = requests.get(url, params)

response.status_code

response.text

response.json()

requests.post(url, data)

Functions

Define and call functions:

def my_function(param1, param2):

    # code

    return result

output = my_function(arg1, arg2)

Working with Files

Reading:

file = open(file_name, "r")

content = file.read()

file.close()

Writing:

file = open(file_name, "w")

file.write(content)

file.close()

Objects and Classes

Define classes and create objects:

class MyClass:

    def init(self, param1, param2):

        self.attr1 = param1

        self.attr2 = param2
def method(self, param):
    return param

obj = MyClass(val1, val2)

obj.method(val3)

List Comprehensions:

squares = [x*x for x in range(10)]

Lambda Functions

add = lambda x, y: x + y

Importing Modules

import math from collections import Counter

Exception Handling: finally

try: # code finally: # always runs

With Statement (Context Managers)

with open('file.txt', 'r') as f: data = f.read()

Type Conversion

int('123')

str(123)

float('3.14')

list('abc')

Basic Numpy/Pandas Usage (for data science focus)

import numpy as np

import pandas as pd

arr = np.array([1,2,3])

df = pd.DataFrame({'a':[1,2], 'b':[3,4]})

Virtual Environments

python -m venv myenv source myenv/bin/activate

Package Installation

pip install requests

Docstrings

def foo(): """This is a docstring.""" pass

Java Interview Questions - Part 3

Garvit Khamesra — Wed, 27 Aug 2025 13:42:06 +0000

Part 3 of the Java interview question series. In this, we will cover

Let's get started

Q31: What are exceptions? Types of Exceptions?

A31: Any event/problem that occurs during the execution of the program, due to which the normal flow of code cannot be attained is known as an Exception. It can occur at compile time or runtime.

There are 2 types of exceptions

Checked Exception - The exceptions which occur at compile time and the compiler lets you know of a possible case where your code can fail or give an error. You won't be able to run your code until these are handled. The phenomenon of handling errors is known as Exception Handling. Eg: FileNotFoundException.
Unchecked Exception - The exceptions which occur at the runtime, the compilation of the program will be a success. These usually occur because of bad logic or improper use of APIs. Eg: ArrayIndexOutOfBoundsException.

Class hierarchy

Q32: Can we write a try block without a catch block?

A32: Yes, we can write but then we need to add finally instead. We can have try block alone.

Q33: When finally block will not get executed?

A33: Whenever the program exits it can happen either when System.exit() is called or when JVM crashes or any other fatal error.

Q34: When we put a throw statement in Finally block, what will happen?

A34: As we know that finally blocks execute every time. The throw statement inside finally will take precedence over try and catch block throw statement.

Q35: Throw vs Throws?

A35: Thow - We can use throw keyword followed by Exception class. This will ask the program to explicitly induce that exception.

Throws - We can add throws keyword in the method signature followed by Exception class, it will tell the compiler that the given method might throw that particular exception mentioned.

Q36: How to make custom checked / unchecked exception?

A36: If you want to make a custom unchecked exception class then extend RuntimeException and for creating a custom checked exception class, extend Exception class.

Q37: Try with Resources

A 37: Try with Resources automatically closes the resource used within the try catch block. This can be done with Java 7 and above versions.

try (FileReader fr = new FileReader("file.txt")) {

} catch (FileNotFoundException e) {
    e.printStackTrace();
} catch (IOException e) {
    e.printStackTrace();
}

It replaces the below code

FileReader fr = null;      
try {
   File file = new File("file.txt");
   fr = new FileReader(file);
} catch (IOException e) {
   e.printStackTrace();
} finally {
   try {
      fr.close();
   } catch (IOException ex) {
      ex.printStackTrace();
   }
}

Q38: Exception Handling with Method Overriding in Java

A38: We would discuss 2 cases

If the parent method does not declare an exception - The child overridden method cannot declare the checked exception but it can declare an unchecked exception.
If the parent method declares an exception - The child overridden method can declare the same, subclass exception, or no exception but cannot declare an exception that has more precedence than the parent class method.

Case 1

import java.io.IOException;

class Parent {
    void method() {

    }
}

class Child extends Parent {
    @override
    void method() {

    }
}

class Child1 extends Parent {
/*
    @override
    void method() throws IOException {
        // 'method()' in 'Child1' clashes with 'method()' in 'Parent'; overridden method does not throw 'java.io.IOException'
    }
*/
}

class Child2 extends Parent {
    @override
    void method() throws ArithmeticException {
        // No error as this is an unchecked exception
    }
}

Case 2

import java.io.FileNotFoundException;
import java.io.IOException;

class Parent {
    void method() throws IOException {

    }
}

class Child extends Parent {
    @override
    void method() {

    }
}

class Child1 extends Parent {
    @override
    void method() throws FileNotFoundException {
    }
}

class Child2 extends Parent {
    @override
    void method() throws IOException {
    }
}

class Child3 extends Parent {
/*
    @override
    void method() throws Exception {
        // error as Exception is superclass to IOException
    }
*/
}

#HappyLearning

Code 101: Tower of Hanoi

Garvit Khamesra — Wed, 27 Aug 2025 13:36:47 +0000

Question:

Towers of Hanoi: In the classic problem of the Towers of Hanoi, you have 3 towers and N disks of different sizes which can slide onto any tower. The puzzle starts with disks sorted in ascending order of size from top to bottom (i.e., each disk sits on top of an even larger one).

You have the following constraints:

(1) Only one disk can be moved at a time.

(2) A disk is slid off the top of one tower onto another tower.

(3) A disk cannot be placed on top of a smaller disk. Write a program to move the disks from the first tower to the

last using Stacks.

Example 1:

Input: 2

Output: Disk 1 moved from A to B

Disk 2 moved from A to C

Disk 1 moved from B to C

Example 2:

Input: 3

Output: Disk 1 moved from A to C

Disk 2 moved from A to B

Disk 1 moved from C to B

Disk 3 moved from A to C

Disk 1 moved from B to A

Disk 2 moved from B to C

Disk 1 moved from A to C

Solution:

By this time we have done several questions on recursion and I believe we can see the similar pattern. Now talking about the problem statement. I feel the best way to solve this question is to first understand how the rings will move and I believe we can understand it better on pen and paper then on code.

First try it yourself and if it does not help, take a look at this animation which helped me to understand the problem better.

Now coming to solution, As we are considering this as a recursion problem we go back to our approach for recursion.

Base Case (when to stop)

As we know that when all the disks are moved from source to destination. We are arrived at a solution, also whenever we are left with the last ring we will move it from source to destination.

if (n == 1) 

move disk from source to destination

return;

Recursive Call (call ourselves)

As by question we can only move 1 ring at a time and we have 3 pegs so we will use them to interchangeably.

recursion(n - 1, from, to, inter)

&

recursion(n - 1, inter, from, to)

Work needed to move toward Base Case or Solution

public static void towerOfHanoi(int n, char origin, char buffer, char destination) {

    if (n == 1) {

        System.out.println("Move disc 1 from "+origin+" to "+ destination);

        return;

    }
towerOfHanoi(n - 1, origin, destination, buffer);
System.out.println("Move disc " + n + " from " + origin + " to " + destination);
towerOfHanoi(n - 1, buffer, origin, destination);

}

Hope you have a better understanding now, continue with the code101 series, and you'll gain a better understanding.

#HappyCoding

Code 101: K-th Symbol in Grammar

Garvit Khamesra — Wed, 27 Aug 2025 13:29:40 +0000

Question

We build a table of n rows (1-indexed). We start by writing 0 in the 1st row. Now in every subsequent row, we look at the previous row and replace each occurrence of 0 with 01, and each occurrence of 1 with 10.

For example, for n = 3, the 1st row is 0, the 2nd row is 01, and the 3rd row is 0110.

Given two integer n and k, return the (1-indexed) symbol in the nth row of a table of n rows.

Example 1:

Input: n = 1, k = 1 Output: 0 Explanation: row 1: 0

Example 2:

Input: n = 2, k = 1 Output: 0 Explanation: row 1: 0 row 2: 01

Example 3:

Input: n = 2, k = 2 Output: 1 Explanation: row 1: 0 row 2: 01

Constraints:

1 <= n <= 30
1 <= k <= 2n - 1

You can find the question here.

Solution:

By reading the question we can deduce that there is some kind of structure we need to create based on the question's requirement. Few things to note here:

To create the structure we need to rely on previous output. So can we use recursion?
The structure is a tree.

After creating the structure mentioned we can deduce few more things.

The size of each row is double the size of previous row.
If we break down the row we can see that the previous row and the first half of the row is exactly same.
The second half of the row is the complement of the previous row

Now we will try to think of a solution keeping all these things in mind. We have previously worked on recursion solutions and we generally break it down to 3 steps.

Base Case (when to stop)
Work needed to move toward Base Case or Solution
Recursive Call (call ourselves)

Let's start with base case, We know that at n = 1 we have zero, lets consider column as k. So at n == 1 and k == 1 we have 0. This becomes our base case.

if (n == 1 && k == 1) return 0;

We will skip second part and move to the 3rd step the recursion calls.

Based on observations we know that the solution depends on the previous output and the complement of previous output.

so can we write 2 recursive calls?

recursion( n-1, k ) -> when k is less the middle element
// and for the second call we need the complement of the values i.e. when the k is greator then the middle // element
recursion( n-1, k - mid) -> when k is less the middle element

Now coming to the second part. Actually while thinking of the 3rd step we kind off got the second part. I'll explain in the code below.

public static int kthGrammar(int n, int k) {
    if(n==1 && k==1) {
        return 0;
    }

    int mid = ((int) pow(2, n - 1)) / 2;

    if(k <= mid) {
        return kthGrammar(n-1, k);
    } else {
        return ( kthGrammar(n-1,k-mid)) ^ 1;
    }
}

See the code does not have anything else then what we discussed, we found mid, we called the recursion calls based on the conditions we knew.

Hope you have a better understanding now, continue with the code101 series, and you'll gain a better understanding.

#HappyCoding

Code 101: Number of Islands

Garvit Khamesra — Wed, 27 Aug 2025 13:24:35 +0000

Question:

Given an m x n 2D binary grid which represents a map of '1's (land) and '0's (water), return the number of islands.

An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically. You may assume all four edges of the grid are surrounded by water.

Example 1:

Input: grid = [
  ["1","1","1","1","0"],
  ["1","1","0","1","0"],
  ["1","1","0","0","0"],
  ["0","0","0","0","0"]
]
Output: 1

Example 2:

Input: grid = [
  ["1","1","0","0","0"],
  ["1","1","0","0","0"],
  ["0","0","1","0","0"],
  ["0","0","0","1","1"]
]
Output: 3

Constraints:

m == grid.length
n == grid[i].length
1 <= m, n <= 300
grid[i][j] is '0' or '1'.

You can find the question here.

Solution:

We have given an 2d array, and asked to find number of islands.

What all things can we deduce from the question

To count the island we need to check where the land end.
All the grid boundaries are considered water.

With this information can we say that we need to traverse the whole array to check where the land is and where the water is?

Also, can we say that whenever we see 1 can we consider it as an Island?

Note: This assumption will count all the '1' as islands.

Will break the answer into smaller parts.

Based on the understanding till now.

public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0) return 0;
        int noOfIslands = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == '1') {
                    noOfIslands++;
                }
            }
        }
        return noOfIslands;
}

With this, we have reached half of the solution but we know that we are counting all the 1 as islands and that is wrong.

So let's say we are standing on a square in a grid and we count that as an island and now wherever you see land attached to the 1 you are standing, consider it as water.

Will doing this solve your duplicate counting problem? Because anyway we are iterating the whole grid, so every time while iterating through the grid we encounter a 1, count it as an island, and mark all the connected land as the water we are good.

Also, we don't want to do anything when we see water.

Now to code our understanding.

public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0) return 0;
        int noOfIslands = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == '1') {
                    noOfIslands++;
                    flippingTheContIslands(grid, i, j);
                }
            }
        }
        return noOfIslands;
}
    
public void flippingTheContIslands(char[][] grid, int i, int j) {
        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == '0' ) {
            return;
        }
        grid[i][j] = '0';
        flippingTheContIslands(grid, i+1, j);
        flippingTheContIslands(grid, i, j+1);
        flippingTheContIslands(grid, i-1, j);
        flippingTheContIslands(grid, i, j-1);
}

Hope you understood the solution.

#HappyCoding

Code 101: Swap Nodes in Pairs

Garvit Khamesra — Wed, 27 Aug 2025 13:01:44 +0000

Question:

Given a linked list, swap every two adjacent nodes and return its head. You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)

Example 1:

Input: head = [1,2,3,4]

Output: [2,1,4,3]

Example 2:

Input: head = [] Output: []

Example 3:

Input: head = [1] Output: [1]

Constraints:

The number of nodes in the list is in the range [0, 100].
0 <= Node.val <= 100

You can find the question here.

Solution:

This question can be solved with both iterative and recursive approaches, But As I'm covering recursion so will start with the recursive approach and then will explain the iterative approach.

Recursive approach

The Base Condition
What to do, to get a solution?
Recursive call

I broke down the solution in these steps.

Now the 1^st step is pretty straightforward. As we know, to swap 2 nodes we need 2 nodes, so let's say we have 2 null checks for that. And for step 3, Can we consider moving to the next node by skipping 1 node? So that we cover every node.

Now coming to 2^nd point.

We know that to swap we need to have 2 nodes, and for swapping we make changes to the next pointer in the list.

Because we are trying to solve it through recursion, for me the problem is to visualize the solution, so I have tried to show using some diagrams.

Let's take an example of list

1-> 2 -> 3-> 4

Now with this example, you should a rough idea of the algorithm. We will use the same logic to code.

    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode next = head.next;
        head.next = swapPairs(next.next);
        next.next = head;
        return next;
    }

Iterative Approach

So if you view the above image it follows a similar approach just we need an additional node.

public ListNode swapPairs(ListNode head) {
    ListNode dummy = new ListNode(0);
    dummy.next = head;
    ListNode current = dummy;
    while (current.next != null && current.next.next != null) {
        ListNode first = current.next;
        ListNode second = current.next.next;
        first.next = second.next;
        current.next = second;
        current.next.next = first;
        current = current.next.next;
    }
    return dummy.next;
}

#HappyCoding

Code 101: Rat in a Maze

Garvit Khamesra — Wed, 27 Aug 2025 03:26:25 +0000

Question:

Consider a rat placed at (0, 0) in a square matrix of order N * N. It has to reach the destination at (N – 1, N – 1). Find all possible paths that the rat can take to reach from source to destination. The directions in which the rat can move are ‘U'(up), ‘D'(down), ‘L’ (left), ‘R’ (right). Value 0 at a cell in the matrix represents that it is blocked and the rat cannot move to it while value 1 at a cell in the matrix represents that rat can travel through it.

Note: In a path, no cell can be visited more than one time.

Print the answer in lexicographical(sorted) order

Examples:

Example 1:
Input:
N = 4
m[][] = `{{1, 0, 0, 0},
        {1, 1, 0, 1}, 
        {1, 1, 0, 0},
        {0, 1, 1, 1}}`

Output: DDRDRR DRDDRR
Explanation:
The rat can reach the destination at (3, 3) from (0, 0) by two paths - DRDDRR and DDRDRR, when printed in sorted order we get DDRDRR DRDDRR.

Example 2:
Input: N = 2
       m[][] = `{{1, 0},
                {1, 0}}`

Output:
 No path exists and the destination cell is blocked.

Solution:

After reading the question, the solution approach is straightforward:

We need to find a path in the maze so that the rat reaches the exit, to do that we just need to start from the initial point and see if we can move to the next block in any of the 4 directions.

Now comes the tricky part how we can code this solution:

By looking at the pattern of our solution we can say this will be a backtracking problem, and also we can see that we can use recursion for our solution.

My idea is to break down the code into smaller pieces so that we don't get confused. That's how I like to approach it.

So I'll start by writing wrappers and the main method, basically all the pre-requisite.

1 more point, we need to find all the paths and also we should not end up visiting the nodes again and again. To handle these 2 conditions we will be using visited nodes array.

package medium.recursion.backtracking;
import java.util.ArrayList;
public class RatInAMaze {
    // Main method to test our code.
    public static void main(String[] args) {
        int n = 4;
        int[][] a = `{{1,0,0,0},{1,1,0,1},{1,1,0,0},{0,1,1,1}}`;
        ArrayList< String > res = findPath(a, n);
        if (res.size() > 0) {
            for (int i = 0; i < res.size(); i++)
                System.out.print(res.get(i) + " ");
            System.out.println();
        } else {
            System.out.println(-1);
        }
    }
    // Based on our solution we have added a new array to maintain visited nodes
    private static ArrayList findPath(int[][] arr, int n) {
        int visited[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                visited[i][j] = 0;
            }
        }
        ArrayList < String > ans = new ArrayList < > ();
        if (arr[0][0] == 1) {
            findPathHelper(arr, n, 0, 0, ans, "", visited);
        }
        return ans;
    }
}

Now we are ready with the test code and the method for our solution. We have defined our helper method as:

findPathHelper(int[][] arr, int n, int i, int j, ArrayList<String> allDiffPaths, String path, int[][] visited)

We are starting from 0,0 and we will be maintaining the current path and all the paths which leads to the solution.

If you haven't gone through Code 101: Sort an Array using Recursion, please have a look at the Recursive Algorithm explained here.

Now as we know we can solve this with recursion, we will try to think of a base condition.

Base Condition:

We know that once the rat reaches the end of the maze it's a success and we add it to our solution.

Now skipping the second point Work needed to move toward Base Case or Solution and moving towards 3rd point the Recursive Call (call ourselves)

As we know the rat can move in 4 directions, so the recursive call corresponding will be

  findPathHelper(arr, n, i+1, j, ans, path + "D", visited);
  findPathHelper(arr, n, i-1, j, ans, path + "U", visited);
  findPathHelper(arr, n, i, j+1, ans, path + "R", visited);
  findPathHelper(arr, n, i, j-1, ans, path + "L", visited);
// Each call is based on each direction and that will be added in path.

Now coming to 2nd point Work needed to move toward Base Case or Solution.

We know that the calls we specified above will be called and the solution will arrive, but there are a few constraints we need to put.

the indices should not be out of bounds
do not visit already visited node
skip the node if it have 0
mark the node visited once the rat is at that node
once you have a path make the visited node as 0 so for the next path you will have the node as not visited

We will write our helper function now:

private static void findPathHelper(int[][] arr, int n, int i, int j, ArrayList ans, String path, int[][] visited) {
        if (i == n-1 && j == n-1) {
            ans.add(path);
            return;
        }

        if (visited[i][j] == 1 || arr[i][j] != 1) {
            return;
        }

        visited[i][j] = 1;

        if (i >= 0 && i + 1 < n && arr[i+1][j] == 1 && visited[i+1][j] != 1) {
            findPathHelper(arr, n, i+1, j, ans, path + "D", visited);
        }

        if (i - 1 >= 0 && i < n && arr[i-1][j] == 1 && visited[i-1][j] != 1) {
            findPathHelper(arr, n, i-1, j, ans, path + "U", visited);
        }

        if (j >= 0 && j+1 < n && arr[i][j+1] == 1 && visited[i][j+1] != 1) {
            findPathHelper(arr, n, i, j+1, ans, path + "R", visited);
        }

        if (j-1 >= 0 && j < n && arr[i][j-1] == 1 && visited[i][j-1] != 1) {
            findPathHelper(arr, n, i, j-1, ans, path + "L", visited);
        }

        visited[i][j] = 0;
    }
}

This will take care of all the scenarios discussed and now consolidate everything into 1 place.

package medium.recursion.backtracking;

import java.util.ArrayList;

public class RatInAMaze {

    public static void main(String[] args) {
        int n = 4;
        int[][] a = `{{1,0,0,0},{1,1,0,1},{1,1,0,0},{0,1,1,1}}`;

        ArrayList< String > res = findPath(a, n);
        if (res.size() > 0) {
            for (int i = 0; i < res.size(); i++)
                System.out.print(res.get(i) + " ");
            System.out.println();
        } else {
            System.out.println(-1);
        }
    }

    private static ArrayList findPath(int[][] arr, int n) {
        int visited[][] = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                visited[i][j] = 0;
            }
        }
        ArrayList < String > ans = new ArrayList < > ();

        if (arr[0][0] == 1) {
            findPathHelper(arr, n, 0, 0, ans, "", visited);
        }
        return ans;
    }

    private static void findPathHelper(int[][] arr, int n, int i, int j, ArrayList ans, String path, int[][] visited) {
        if (i == n-1 && j == n-1) {
            ans.add(path);
            return;
        }

        if (visited[i][j] == 1 || arr[i][j] != 1) {
            return;
        }

        visited[i][j] = 1;

        if (i >= 0 && i + 1 < n && arr[i+1][j] == 1 && visited[i+1][j] != 1) {
            findPathHelper(arr, n, i+1, j, ans, path + "D", visited);
        }

        if (i - 1 >= 0 && i < n && arr[i-1][j] == 1 && visited[i-1][j] != 1) {
            findPathHelper(arr, n, i-1, j, ans, path + "U", visited);
        }

        if (j >= 0 && j+1 < n && arr[i][j+1] == 1 && visited[i][j+1] != 1) {
            findPathHelper(arr, n, i, j+1, ans, path + "R", visited);
        }

        if (j-1 >= 0 && j < n && arr[i][j-1] == 1 && visited[i][j-1] != 1) {
            findPathHelper(arr, n, i, j-1, ans, path + "L", visited);
        }

        visited[i][j] = 0;
    }
}

Now that we have completed the code, I wanted to organize it better and removed pieces that we can remove.

private static void findPathHelper(int[][] arr, int n, int i, int j, ArrayList ans, String path) {
    if (i < 0 || j < 0 || i >= arr.length || j >= arr[0].length || arr[i][j] == 0 || arr[i][j] ==  -1) {
        return;
    }

    if (i == n-1 && j == n-1) {
        ans.add(path);
        return;
    }

    arr[i][j] = -1;
    findPathHelper(arr, n, i+1, j, ans, path + "D");
    findPathHelper(arr, n, i-1, j, ans, path + "U");
    findPathHelper(arr, n, i, j+1, ans, path + "R");
    findPathHelper(arr, n, i, j-1, ans, path + "L");
    arr[i][j] = 1;
}

#HappyCoding

Code 101: Sort a Stack using Recursion

Garvit Khamesra — Wed, 27 Aug 2025 03:12:35 +0000

Question:

Given a stack, sort it using recursion. Use of any loop constructs like while, for..etc is not allowed.

Solution:

This question follows the same algorithm as Sort an Array using recursion. So I would suggest you go through the post and try it once.

I have added the code and the call order because once go through it you'll see the code is similar.

package stack.queue;
import java.util.Stack;
public class SortStackWithRecursion {
    static Stack stack;
    public static void sort() {
        if (!stack.isEmpty()) {
            int temp = stack.pop();
            sort();
            insert(temp);
        }
    }
    private static void insert(int value) {
        if (stack.isEmpty() || stack.peek() < value) {
            stack.push(value);
        } else {
            int temp = stack.pop();
            insert(value);
            stack.push(temp);
        }
    }
    public static void main(String[] args) {
        stack = new Stack<>();
        stack.add(12112);
        stack.add(21);
        stack.add(300);
        stack.add(41);
        stack.add(52);
        for (int i : stack) {
            System.out.print(i + " ,");
        }
        System.out.println("\n>>>");
        sort();
        System.out.println("<<<");
        for (int i : stack) {
            System.out.print(i + " ,");
        }
    }
}

Sort [12112, 21, 300, 41, 52] Stack Size: 5
Sort [12112, 21, 300, 41] Stack Size: 4
Sort [12112, 21, 300] Stack Size: 3
Sort [12112, 21] Stack Size: 2
Sort [12112] Stack Size: 1
Insert [] Stack Size: 0
Inserting Value: 12112
Insert [12112] Stack Size: 1
Insert [] Stack Size: 0
Inserting Value: 21
Inserting Value: 12112
Insert [21, 12112] Stack Size: 2
Insert [21] Stack Size: 1
Inserting Value: 300
Inserting Value: 12112
Insert [21, 300, 12112] Stack Size: 3
Insert [21, 300] Stack Size: 2
Insert [21] Stack Size: 1
Inserting Value: 41
Inserting Value: 300
Inserting Value: 12112
Insert [21, 41, 300, 12112] Stack Size: 4
Insert [21, 41, 300] Stack Size: 3
Insert [21, 41] Stack Size: 2
Inserting Value: 52
Inserting Value: 300
Inserting Value: 12112

#HappyCoding

Code 101: Sort an Array using Recursion

Garvit Khamesra — Wed, 27 Aug 2025 03:08:01 +0000

Question:

Given an array of integers nums, sort the array in ascending order.

Example 1:

Input: nums = [5,2,3,1] Output: [1,2,3,5]

Example 2:

Input: nums = [5,1,1,2,0,0] Output: [0,0,1,1,2,5]

Constraints:

1 <= nums.length <= 5 * 104
-5 * 104 <= nums[i] <= 5 * 104

Solution:

Let's start with Recursion.

I found this definition while starting with recursion and found it useful.

Recursion is the process of defining a problem (or the solution to a problem) in terms of (a simpler version of) itself.

Recursive Algorithm

All recursive algorithms must have the following:

Base Case (when to stop)
Work needed to move toward Base Case or Solution
Recursive Call (call ourselves)

Now coming back to the problem, we know that we need to breakdown our solution in above 3 points

Think when do you tell an array to be sorted.
if the size is zero?
if the size is 1?
if the array is in ascending order :)?
Now can we make a recursive call to attain 1.a?
yes, if we make a recursive call by decreasing the size of the array
Now we will try to code what we just thought.

public class SortArray {
    public static void sort(int[] arr, int n) {
        if (n == 0) return;
        sort(arr, n-1);
    }
    public static void main(String[] args) {
        int[] arr = new int[] {3, 4, 2, 6, 1, 1, 9, 1};
        for (int i : arr) {
            System.out.print(i + " ,");
        }
        System.out.println("\n>>>");
        sort(arr, arr.length - 1);
        System.out.println("<<<");
        for (int i : arr) {
            System.out.print(i + " ,");
        }
    }
}

Now we will think how we can achieve 1. c
Let's say we have an empty array. Now if we want to add an element to it and the resultant should be a sorted array.
so we can add the element directly in this case, correct?
Let's say we have a sorted array. Now if we want to add an element to it and the resultant should be a sorted array.
so if the element is greater than the last element then we can add the element directly at the end in this case, correct?
if the element is shorter than the last element then we need to put it in between the array, at its correct place. Now, don't you think this is again pointing to recursion, because we need to go to a place where we can insert the element in the array and it will be sorted.
Now we know that we need 2 recursive functions
sort
insert
With this, we will again try to write a code
Now adding to the last piece of code we have written. It was reducing or array by 1 in each call so we need to add those back at the correct place.

public static void sort(int[] arr, int n) {
    if (n == 0) return;
    int val = arr[n];
    sort(arr, n-1);
    insert(arr, val, n);
}
// So we just took the last element and put it at it's correct position

Now to insert elements back we will write the insert method.

private static void insert(int[] arr, int value, int n) {
    if (n == 0 || arr[n-1] <= value) {
        arr[n] = value;
    } else {
        int val = arr[n-1];
        insert(arr, value, n - 1);
        arr[n] = val;
    }
}

Code and The order of the calls

import java.util.Arrays;

public class SortArray {
    public static void sort(int[] arr, int n) {
        if (n == 0) return;
        int val = arr[n];
        sort(arr, n-1);
        insert(arr, val, n);
    }
    private static void insert(int[] arr, int value, int n) {
        if (n == 0 || arr[n-1] <= value) {
            arr[n] = value;
        } else {
            int val = arr[n-1];
            insert(arr, value, n - 1);
            arr[n] = val;
        }
    }
    public static void main(String[] args) {
        int[] arr = new int[] {9, 4, 2, 9, 1};
        for (int i : arr) {
            System.out.print(i + " ,");
        }
        System.out.println("\n>>>");
        sort(arr, arr.length - 1);
        System.out.println("<<<");
        for (int i : arr) {
            System.out.print(i + " ,");
        }
    }
}

Sort [9, 4, 2, 9, 1] Arr Size: 4
Sort [9, 4, 2, 9, 1] Arr Size: 3
Sort [9, 4, 2, 9, 1] Arr Size: 2
Sort [9, 4, 2, 9, 1] Arr Size: 1
Sort [9, 4, 2, 9, 1] Arr Size: 0
Insert [9, 4, 2, 9, 1] Arr Size: 1
Insert [9, 4, 2, 9, 1] Arr Size: 0
Inserting Value: 4 at 0
Inserting Value: 9 at 1
Insert [4, 9, 2, 9, 1] Arr Size: 2
Insert [4, 9, 2, 9, 1] Arr Size: 1
Insert [4, 9, 2, 9, 1] Arr Size: 0
Inserting Value: 2 at 0
Inserting Value: 4 at 1
Inserting Value: 9 at 2
Insert [2, 4, 9, 9, 1] Arr Size: 3
Inserting Value: 9 at 3
Insert [2, 4, 9, 9, 1] Arr Size: 4
Insert [2, 4, 9, 9, 1] Arr Size: 3
Insert [2, 4, 9, 9, 1] Arr Size: 2
Insert [2, 4, 9, 9, 1] Arr Size: 1
Insert [2, 4, 9, 9, 1] Arr Size: 0
Inserting Value: 1 at 0
Inserting Value: 2 at 1
Inserting Value: 4 at 2
Inserting Value: 9 at 3
Inserting Value: 9 at 4

Hope you have a better understanding now, continue with the code101 series, and you'll gain a better understanding.

#HappyCoding

Java Interview Questions - Part 2

Garvit Khamesra — Tue, 26 Aug 2025 03:17:54 +0000

Part 2 of the [Java interview question series](https://dev.to/garvit_khamesra/java-interview-questions-part-1-3ba7). In this, we will cover static, abstract classes and methods, and interfaces.

Before we start with the questions I would recommend going through these 3 articles.

Let's get started

Q21: Why is main a static method?

A21: Main method is an entry point of execution in java. JVM has been following this signature to locate the entry point. If we change the signature of the method, the program compiles but does not execute. The main() method in Java must be declared public, static, and void. If any of these are missing, the Java program will compile but a runtime error will be thrown.

Q22: Can we override static methods?

A22: No, We cannot override static methods because the binding is done at compile time. Even if we create an overridden method, it will not have any effect because runtime polymorphism is not possible.

Example:

class Parent {
    static void staticMethod() {
        System.out.println("Parent Method");
    }
}
class Child extends Parent {
    static void staticMethod() {
        System.out.println("Child Method");
    }
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();
        Child child1 = new Child();
        parent.staticMethod();
        child.staticMethod();
        child1.staticMethod();
    }
}

Q23: Can we make constructors static?

A23: No, Contrustors are called when the object is created and static refers to class level properties and not the object level. Even if we try to put static keyword in front of the constructor it will give us an error.

Q24: Can we make the abstract methods static?

A24: We write abstract methods so that we can override them. So now this question is similar to Can we override static methods. For both, the answer is no with same reasoning.

Q25: What is covariant return type?

A25: Before Java5, it was not possible to override methods by changing the return type. But now, we can change the return type to the sub-class type.

Example:

class Parent {
     Parent parentMethod() {
        System.out.println("Parent Method");
        return new Parent();
    }
}
class Child extends Parent {
     Child parentMethod() {
        System.out.println("Child Method");
        return new Child();
    }
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent child = new Child();
        Child child1 = new Child();
        parent.parentMethod();
        child.parentMethod();
        child1.parentMethod();
    }
}

Q26: Can we declare main method as final?

A26: Yes, we cab have main method as final. The compiler will not give any error and it will work also. But the final keyword is used such that the method cannot be overridden. But as main method already have static which makes it not supported for override.

Q27: Can we declare a constructor as final?

A27: We cannot declare constructor as final, the compiler will throw an error.

"Constructor declarations are not members. They are never inherited and therefore are not subject to hiding or overriding."

And final keyword is used to prevent overriding, so adding final will not make sense.

Q28: Can we declare an interface as final?

A28: No, we cannot declare an interface as final because the interface must be implemented by some class to provide its definition, and the use of final is to prevent that behavior. Therefore, there is no sense to make an interface final. If we try to do so, the compiler will show an error.

Q29: Can we declare an abstract method as final?

A29: We cannot declare an abstract method as final, because final is used to prevent overriding and abstract methods must be overridden by a subclass. If we try to do so, the compiler will show an error.

Q30: Can we declare an abstract method as private?

A30: We cannot use a private modifier with an abstract method, because a private modifier restricts access to the given class and the abstract methods must be overridden by a subclass. If we try to do so, the compiler will show an error.

#HappyLearning

Static Keyword in Java

Garvit Khamesra — Tue, 26 Aug 2025 03:11:57 +0000

Static Keyword

We can use the Static keyword in 5 places.

Import Statement
Block
Class
Method
Variable

Static Import Statement

We use import statements to import classes from different packages, adding static to those import statements will only import the static members of the class.

Example:

import static {package name}.{static member name};

import static java.lang.System.out;

Static Block

We create a static block by adding a static keyword before a pair of curly braces.

Example:

static {

    staticVariable = 24; // initializing static variable

 }

Few points to remember about the static block.

It is used to initialize the static variables.
It is executed before the main method, It is executed when the class is loaded in the memory.
We can have multiple static blocks in a class and these are executed in the same sequence in which they appear in the class definition.

Static Class

There are a few constraints while dealing with static class.

A class can be made static only if it is a nested class. We cannot declare a top-level class with a static modifier.
Nested static class doesn’t need a reference of Outer class.
A static class cannot access non-static members of the Outer class.

Below is an example of a static nested class.

Example:

public class StaticClassExample {

    public static void main(String[] args) {

        //Static inner class example

        DataObject.StaticInnerClass.accessOuterClass();

    }

}

class DataObject {

    public int nonStaticVariable;

    public static int staticVariable;  //static variable
static {
    staticVariable = 40;
    //nonStaticVariable = 20;  //Not possible to access non-static members
}
public static int getStaticVariable(){
    return staticVariable;
}
static class StaticInnerClass {
    public static void accessOuterClass() {
        System.out.println(DataObject.staticVariable);   //static variable of outer class
        System.out.println(DataObject.getStaticVariable());  //static method of outer class
        System.out.println(staticVariable);   //static variable of outer class
        System.out.println(getStaticVariable()); // static method of outer class
        // System.out.println(DataObject.nonStaticVariable); // Not Possible
    }
}

}

Static Methods

Few points to remember about the static methods.

Static methods can be accessed via its class reference.
Static methods can call other static methods.
Static methods also belong to the class-level scope.
Static methods can access static data members and can change their value.
They cannot refer to this or super in any way.

Example:

public static int getStaticVariable(){

      return staticVariable;

}

Static Variables

Static variables are Class level properties. They do not vary based on the objects of the class.

We can demonstrate this by the below code example, where we have a counter which is static and non-static.

Example:

public class StaticClassExample {

    public static void main(String[] args) {

        DataObject object1 = new DataObject();

        DataObject object2 = new DataObject();

        DataObject object3 = new DataObject();

        DataObject object4 = new DataObject();

    }

}

class DataObject {

    public int nonStaticVariable;

    public static int staticVariable;
public DataObject() {
    nonStaticVariable++;
    staticVariable++;
    System.out.println(staticVariable);
    System.out.println(nonStaticVariable);
}

}

#HappyCoding

Code 101: Longest Valid Parentheses ( LeetCode Hard Problem )

Garvit Khamesra — Tue, 26 Aug 2025 02:57:19 +0000

Question:

Given a string containing just the characters '(' and ')', find the length of the longest valid (well-formed) parentheses substring.

Example 1:

Input: s = "(()" Output: 2 Explanation: The longest valid parentheses substring is "()".

Example 2:

Input: s = ")()())" Output: 4 Explanation: The longest valid parentheses substring is "()()".

Example 3:

Input: s = "" Output: 0

Constraints:

0 <= s.length <= 3 * 104
s[i] is '(', or ')'.

You can find the question here.

Solution:

Stack Approach

First thing whenever I see questions that have something to balance, validate, or format, I think in terms of the stack. The first thought is to check can we solve this with the stack.

Coming to the problem, How do we say a parenthesis is valid? Whenever we see 1 closing and corresponding opening parenthesis.

How do we say a parenthesis is invalid? Whenever we see a closing parenthesis without an opening parenthesis. We cannot say the same for the opening parenthesis because we can say that in the future a closing parenthesis might come.

Also, we need to find the longest valid string length, so we need to maintain the size some place.

Now with this information, we can derive an algorithm to solve this.

Let's say we iterate the string and

Whenever we encounter '(' we add it's index to the stack.
Whenever we encounter ')' now we need to check if there is any valid combination to add to out result or not.
To calculate max length we need to check the index with the index of the '(' which will be present in the stack top.
There are a few scenarios that are missed above.
What happens when there is String "()" -> result would be 1 instead of 2
What if we have more ')', That means we have an invalid string starting. So now we need to restart our calculation. We will do that by adding the index of the invalid string start
Edge case: only ')'

I have added inline comments in the code for a better understanding of the algorithm.

import java.util.Stack;

public class LongestValidParenthesis {
    public static int longestValidParentheses(String s) {
        int res = 0; // Initial length
        Stack<Integer> st = new Stack<>(); // Initialize the stack
        st.push(-1); // Added to handle edge case
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(') {
                st.push(i);
            } else {
                if (st.size() > 1 && s.charAt(st.peek()) == '(') {
                    st.pop();
                    res = Math.max(res,i - st.peek()); // calc the length of valid string
                } else {
                    st.push(i); // To handle invalid scenarios 
                }
            }
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println(longestValidParentheses(")()())))"));
    }
}

Above is 1 approach to solve this question. Once I understood this, I wanted to check what all other solutions could be possible for this question.

I found there are 2 more ways to solve this.

Dynamic Programing
Without extra space

Dynamic Programming Approach

Dp problems consist of 2 parts, 1st subproblem, and 2nd memoization.

The condition for valid and invalid remains the same for every approach. So now the subproblem will be something when we have ) do we have corresponding ( and we will maintain the length of each valid substring.

The below code demonstrates the same algo, I have added inline comments for better understanding.

public class LongestValidParenthesis {

    public static int longestValidParenthesesDP(String str) {
        int res = 0;
        int dp[] = new int[str.length()];
        for (int i = 1; i < str.length(); i++) {
            if (str.charAt(i) == ')') { // Whenever we encounter ')'
                if (str.charAt(i - 1) == '(') { // We need to check if the character before is '(' or not
                    dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2; // if true we just add 2 to the previously calculated length of valid substring
                } else if (i - dp[i - 1] > 0 && str.charAt(i - dp[i - 1] - 1) == '(') {
                    // i - dp[i-1] -1 means we are pointing to the index just before we had a valid string,
                    // because the dp[i-1] has the valid substring length
                    // once we at that index we need to check that the index is having '('
                    // this means we have addition to our valid substring
                    dp[i] = dp[i - 1] + ((i - dp[i - 1]) >= 2 ? dp[i - dp[i - 1] - 2] : 0) + 2;
                }
                res = Math.max(res, dp[i]);
            }
        }
        return res;
    }

    public static void main(String[] args) {
        System.out.println(longestValidParenthesesDP(")()())))"));
    }
}

Without Extra Space

This solution I did not think, I just read it from the solution and find it interesting so thought to add it.

Here the idea remains the same, only now we use 2 pointers and we traverse 2 times, 1 left to right & 1 right to left.

The below code demonstrates the same algo, I have added inline comments for better understanding.

public int longestValidParenthesesWithoutExtraSpace(String s) {
    int left = 0, right = 0, maxlength = 0;
    for (int i = 0; i < s.length(); i++) {
        if (s.charAt(i) == '(') {
            left++;
        } else {
            right++;
        }
        if (left == right) { // string is valid
            maxlength = Math.max(maxlength, 2 * right);
        } else if (right >= left) { // string becomes invalid
            left = right = 0;
        }
    }

    // Second iteration is to make sure if we had left more from left -> right which when traverse from right -> left
    // can contribute to max length 
    left = right = 0;
    for (int i = s.length() - 1; i >= 0; i--) {
        if (s.charAt(i) == '(') {
            left++;
        } else {
            right++;
        }
        if (left == right) { // string is valid
            maxlength = Math.max(maxlength, 2 * left);
        } else if (left >= right) { // String becomes invalid
            left = right = 0;
        }
    }
    return maxlength;
}

#HappyCoding