DEV Community: Prashant Mishra

Pattern: Matrix Manupulation

Prashant Mishra — Mon, 27 Apr 2026 16:27:18 +0000

Matrix manipulation involves, matrix traversal and manipulation based on matrix properties
Example: Rotate Image

class Solution {
    public void rotate(int[][] matrix) {
        //replacing rows with columns
        int m = matrix.length;
        int n = matrix[0].length;
        for(int i = 0;i<m;i++){
            for(int j = 0;j<i;j++){
                swap(i,j,m,n,matrix);
            }
        }

        //swapping the columns
        int p = 0; int q = n-1;
        while(p<q){
            for(int i =0;i<m;i++){
                int temp = matrix[i][p];
                matrix[i][p] = matrix[i][q];
                matrix[i][q] = temp;
            }
            p++;
            q--;
        }
    }
    public void swap(int i, int j, int m ,int n, int matrix[][]){
        int temp = matrix[i][j];
        matrix[i][j] = matrix[j][i];
        matrix[j][i] = temp;
    }
}

Pattern: Reverse LinkedList

Prashant Mishra — Mon, 27 Apr 2026 16:16:14 +0000

Reverse a LinkedList

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        while(head!=null){
            ListNode temp = head.next;
            head.next = prev;
            prev = head;
            head = temp;
        }
        return prev;
    }
}

Pattern:Cyclic Sort

Prashant Mishra — Mon, 27 Apr 2026 16:06:56 +0000

Cyclic Sort: Instead of comparing elements like normal sorting, you place each number directly at its correct index.

Example: Find all the numbers disappeared in an array

class Solution {
    public List<Integer> findDisappearedNumbers(int[] nums) {

        int  i =0;
        int n = nums.length;
        while(i<n){
            int correctIndex = nums[i]-1;
            //ignore all the out of bound indexes
            if(correctIndex < nums.length && correctIndex >=0 && nums[i] != nums[correctIndex]){
                swap(i,correctIndex,nums);
            }
            else i++;
        }
        List<Integer> list = new ArrayList<>();
        for(i =0;i<nums.length;i++){
            if((i+1)!=nums[i]) list.add(i+1);
        }
        return list;
    }
    public void swap(int i, int j, int arr[]){
        int temp = arr[i];
        arr[i]= arr[j];
        arr[j] = temp;
    }
}

Pattern: Two Pointer

Prashant Mishra — Fri, 24 Apr 2026 14:39:57 +0000

Problems where we can use two pointers i,j to get to a solution in the given Array or String
Example : Two Sum II Input Arrays is Sorted
Here we have find two indices from the given array such that sum of those indices value is target (condition index1< index2)

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int l=  0;
        int r = numbers.length-1;
        while(l<r){
            int sum = numbers[l] + numbers[r];
            if(sum == target) return new int[]{l+1,r+1};
            else if(sum < target) l++;
            else r--;
        }
        return new int[-1];
    }
}

Pattern: sliding window (Variable window)

Prashant Mishra — Fri, 24 Apr 2026 14:17:56 +0000

Sliding window of variable size that satisfy given constraint, i.e
Finding continuous substring/subarray that satisfies the given condition.
e.g. Longest substring without repeating characters

class Solution {
    public int lengthOfLongestSubstring(String s) {
        int l = 0;
        int r = 0;
        int size = 0;
        int arr[]  = new int[256];
        Arrays.fill(arr,-1); //intially indices of all the characters are -1

        while(r<s.length()){
            char c = s.charAt(r);
            if(arr[c]!=-1){ //seen in the past
                if(arr[c] >=l){ // if it was seen after the left index then we have a duplicate in the range of l and r we have to move the left pointer
                    l = arr[c]+1; 
                }

            }
            arr[c] = r;
            size= Math.max(size, r-l+1);
            r++;
        }
        return size;
    }
}

Pattern: Sliding window (fixed window)

Prashant Mishra — Thu, 23 Apr 2026 16:37:21 +0000

Problems that involves operations on contiguous range of substring/subarray
eg. Maximum sum subarray of size k (Fixed window of size K)

class Solution {
    public int maxSubarraySum(int[] arr, int k) {
        // Code here
        int left  =0;
        int right  =0;
        int sum = 0;
        int max = Integer.MIN_VALUE;
        while(right<arr.length){
            if(right-left+1<k){
                sum+=arr[right];
                right++;
            }
            else{
                sum+=arr[right];
                max = Math.max(max, sum);
                sum = sum-arr[left];
                left++;
                right++;
            }
        }
        return  max;
    }
}

Pattern: Prefix sum

Prashant Mishra — Wed, 22 Apr 2026 16:58:31 +0000

Prefix sum: involves storing sum/product upto each index for quick access/lookup for range queries
e.g. Product of Array Except Self

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int a[] =  new int[nums.length];
        int b[] = new int[nums.length];
        a[0] = nums[0];
        b[nums.length-1] = nums[nums.length-1];
        for(int i =1;i< nums.length;i++){
            a[i]  = a[i-1]*nums[i];
        }
        for(int i  = nums.length-2;i>=0;i--){
            b[i] = nums[i]*b[i+1];
        }
        System.out.println();
        for(int i = 0;i< nums.length;i++){
            nums[i] = (i-1 >=0 ? a[i-1] : 1) * (i+1 <=nums.length-1 ? b[i+1] : 1); 
        }
        return nums;
    }
}

Pattern: Overlapping intervals

Prashant Mishra — Wed, 22 Apr 2026 10:30:42 +0000

Given list of (start and end time/sequence) we have to merge the overlapping intervals.
eg: Merge Overlapping intervals

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals, (a,b)-> a[0] - b[0]);// sort by starting time
        List<List<Integer>> list  = new ArrayList<>();
        int start = intervals[0][0]; int end = intervals[0][1];
        for(int i =1;i< intervals.length;i++){
            if(end >= intervals[i][0]){
                end = Math.max(end, intervals[i][1]);
                continue;
            }
            else{
                List<Integer> l = new ArrayList<>();
                l.add(start);
                l.add(end);
                list.add(l);
                start = intervals[i][0];
                end = intervals[i][1];
            }
        }
        List<Integer> l = new ArrayList<>();
        l.add(start);
        l.add(end);
        list.add(l);
        int result[][] = new int[list.size()][2];
        for(int i = 0;i< list.size();i++){
            result[i][0] = list.get(i).get(0);
            result[i][1] = list.get(i).get(1);
        }
        return result;
    }
}

Pattern: Slow fast pointer

Prashant Mishra — Wed, 22 Apr 2026 09:06:08 +0000

If we use slow and fast pointer at some point fast pointer and slow pointer will point to the same node.
Example: Detect cycle in the graph

public class Solution {
    public boolean hasCycle(ListNode head) {
         if(head ==null || head.next ==null) return false;
        ListNode slow = head;
        ListNode fast = slow.next;
        while(fast!=null){
            if(slow ==fast) return true;
            slow = slow.next;
            fast = fast.next ==null ? null : fast.next.next;
        }
        return false;
    }
}

Design LinkedList

Prashant Mishra — Sat, 26 Jul 2025 17:10:30 +0000

Problem

class MyLinkedList {
    Node head;
    Node tail;
    int size = 0;
    public MyLinkedList() {
    }

    public int get(int index) {
        if(index<0 || index>=size) return -1;
        Node temp = head;
        int c = 0;
        while(temp!=null){
            if(c == index) return temp.val;
            c++;
            temp = temp.right;
        }
        return -1;
    }

    public void addAtHead(int val) {
        if(head==null && tail==null){
            Node node = new Node(val);
            head = node;
            tail = node;
        }
        else {
            Node node = new Node(val);
            node.right = head;
            head.left  = node;
            head = node;
        }
        size++;
        //print("add at head val: "+ val, head);
    }

    public void addAtTail(int val) {
        if(head==null && tail==null){
            Node node= new Node(val);
            head = node;
            tail = node;
        }
        else{
            Node node = new Node(val);
            tail.right = node;
            node.left = tail;
            tail = node;
        }
        size++;
        //print("add at tail: "+val, head);
    }

    public void addAtIndex(int index, int val) {
        if(index<0 || index> size) return;
        if(index == size){
            //add at tail
            addAtTail(val);
            return;
        }
        else if(index ==0){
            addAtHead(val);
            return;
        }
        //Otherwise add at somewhere in the middle
        Node node = new Node(val);
        Node temp = head;
        int c = 0;
        while(temp!=null){
            if(c == index) break;
            c++;
            temp = temp.right;
        }
        Node leftPartNode  = temp.left;
        node.right = temp;
        temp.left  =node;
        leftPartNode.right = node;
        node.left = leftPartNode;
        size++;
        //print("after add at index "+index +",val "+ val , head);
    }

    public void deleteAtIndex(int index) {
        if(index<0 || index>=size) return;
        if(head == tail){
            head =null;
            tail =null;
            size--;
            return;
        }
        if(index ==0){
            head = head.right;

        }
        else if(index == size-1){
            tail = tail.left;
            tail.right = null;
        }
        else{
            int c= 0;
            Node temp  = head;
            while(temp!=null){
                if(c == index) break;
                c++;
                temp = temp.right;
            }
            Node leftPartNode = temp.left;
            Node rightPartNode = temp.right;
            leftPartNode.right = rightPartNode;
            rightPartNode.left = leftPartNode;
            temp.left  =null;
            temp.right = null;
        }
        size--;
       // print("deletion at index "+index, head);
    }
    public void print(String purpose, Node head){
        System.out.println(purpose + ",current list size "+ size);
        Node temp  = head;
        System.out.print("null<-");
        while(temp!=null){
            System.out.print(temp.val +"->");
            temp = temp.right;
        }
        System.out.print("null");
        System.out.println();
    }
}
class Node{
    Node left;
    Node right;
    int val;
    public Node(int d){
        this.val = d;
    }
    public Node(int d, Node l, Node right){
        this.val = d;
        this.left = l;
        this.right = right;
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

Safest Walk through the grid

Prashant Mishra — Sat, 12 Jul 2025 13:51:05 +0000

Problem

class Solution {
    public boolean findSafeWalk(List<List<Integer>> grid, int health) {
        Queue<Data> q  = new PriorityQueue<>((a,b)-> Integer.compare(b.h,a.h));
        q.add(new Data(0,0,health-grid.get(0).get(0)));
        int m = grid.size();
        int n = grid.get(0).size();
        int dirs[][] = {{0,-1},{0,1},{-1,0},{1,0}};
        int visited[][] = new int[m][n];
        while(!q.isEmpty()){
            Data d = q.remove();
            if(d.i ==m-1 && d.j == n-1) return true;
            for(int dir[] : dirs){
                int i = d.i + dir[0];
                int j = d.j + dir[1];
                if(i>=0 && j>=0 && i< m && j<n && visited[i][j] ==0 && d.h - grid.get(i).get(j) >0){
                    visited[i][j]  = 1;
                    int h = d.h - grid.get(i).get(j);
                    q.add(new Data(i,j,h));
                }
            }
        return false;
    }
class Data{
    int i;
    int j;
    int h;
    public Data(int i, int j, int h){
        this.i = i;
        this.j = j;
        this.h = h;
    }
}

Swim in rising water

Prashant Mishra — Sat, 12 Jul 2025 13:32:50 +0000

Problem

class Solution {
    public int swimInWater(int[][] grid) {
        Queue<Data> q = new PriorityQueue<>((a,b)-> Integer.compare(a.t, b.t));
        q.add(new Data(0,0,grid[0][0]));
        int dirs[][] = {{0,1},{1,0},{0,-1},{-1,0}};
        int visited[][] = new int[grid.length][grid[0].length];
        while(!q.isEmpty()){
            Data d = q.remove();
            if(d.i == grid.length-1 && d.j == grid[0].length-1) {
                return d.t;
            }
            for(int dir[] : dirs){
                int i = dir[0] + d.i;
                int j = dir[1] + d.j;
                if(i>=0 && i< grid.length && j>=0 && j<grid[0].length && visited[i][j]==0 ){
                    visited[i][j] = 1;
                    q.add(new Data(i,j, Math.max(d.t, grid[i][j])));
                }
            }
        }
        return -1;
    }
}
class Data{
    int i;
    int j;
    int t;
    public Data(int i, int j, int t){
        this.i  =i;
        this.j = j;
        this.t = t;
    }
}