DEV Community: Prashant Mishra

Remove Nth node from the end of the LinkedList

Prashant Mishra — Wed, 24 Jun 2026 16:18:49 +0000

Remove Nth node from the end of the 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 removeNthFromEnd(ListNode head, int n) {
        ListNode first = head;
        ListNode sec = head;
        while(n-->0){
            first = first.next;
        }
        if(first ==null) return head.next;
        ListNode temp  = sec;
        while(first!=null){
            first = first.next;
            temp  = sec;
            sec = sec.next;
        }
        temp.next = sec == null ? null : sec.next;
        return head;
    }
}

Minimize max distance to gas station

Prashant Mishra — Mon, 22 Jun 2026 16:59:06 +0000

Minimize max distance to gas station

class Solution {
    public double minMaxDist(int[] stations, int K) {
        // code here
        double min = 0;
        double max = 0;
        for(int i =1;i<stations.length;i++){
            max = Math.max(max,stations[i]-stations[i-1]);
        }
        double result = 0.000000;
        while(max-min > 1e-6){
            double mid = (min+max)/2.0;
            if(isPossible(mid,K, stations)){
                max = mid;
            }
            else min = mid;
        }
        return max;
    }
    public boolean isPossible(double dis, int K , int stations[]){
        int count =0;
        for(int i = 1;i< stations.length;i++){
            double gap = stations[i]-stations[i-1];
            count+=  (int) (gap/dis);
            if(gap % dis==0) count--; // very important because if gap is exactly divisible then adding (quotient) no of stations in between i and i-1 wouuld reduce the min distance lower than dis(check value) 
        }
        return count<=K;
    }
}

Allocate minimum pages

Prashant Mishra — Wed, 17 Jun 2026 17:38:12 +0000

Allocate minimum pages

class Solution {
    public int findPages(int[] arr, int k) {
        if(k> arr.length) return -1;
        // code here
        int min = arr[0];
        int max = 0;
        for(int i: arr){
            max+=i;
            min = Math.max(min, i);// min should be such that it is the max vaule of the arr 
            //othewise if arr[i] > min then that book can not be assigned to a single 
            //student and we can not partially assign 1 book to 2 students
        }
        int result = -1;

        while(min<=max){
            int mid = (min+max)/2;
            if(isPossible(mid, arr, k)){
                result = mid;
                max = mid-1;
            }
            else min = mid+1;
        }
        return result;
    }

    public boolean isPossible(int minPage, int [] arr, int k){
        int noOfStudents  = 1; //one student will satisfy the condition 
        int currentPage = 0;
        for(int pages : arr){
            //per student max pages(currentPage+pages) assigned should be less than or equal to minPage else we will to assign
            // that pages(i.e arr[i] to the next student) 
            if(pages + currentPage > minPage){
                currentPage =0; //reset the currentPage for the new student
                noOfStudents++;
            }
            currentPage+=pages;// currentPage will initialize with the current ith page i.e pages here 
        }
        return noOfStudents<=k;
    }
}

Aggressive Cows

Prashant Mishra — Tue, 16 Jun 2026 16:59:06 +0000

Aggressive cows

class Solution {
    public int aggressiveCows(int[] stalls, int k) {
        // code here
        Arrays.sort(stalls);//sorted will help us in getting the maxDistance as the stalls would be sorted as per the distance
        int min = 1;// the min distance between the stall would be 1
        int max = stalls[stalls.length-1] - stalls[0]; // this would be the max distance between the fardest stalls
        int result = Integer.MIN_VALUE;

        while(min<=max){
            int mid = (min+max)/2;
            if(isPossible(mid, stalls, k)){
                result = Math.max(result, mid);
                min = mid+1;
            }
            else{
                max = mid-1;
            }
        }
        return result;

    }

    public static boolean isPossible(int maxDistance, int stalls[], int k){
        int noOfCowsOnStall = 1;//first cow will always be on first stall t og
        //to get the min distance that could be maxinum
        int indexOfPreviousStall = 0;
        for(int i =1;i<stalls.length;i++){
            //the distance should be more than or atleast the maxDistance for maxDistance to be
            //a valid answer
            if(stalls[i]- stalls[indexOfPreviousStall]>=maxDistance){
                //cow can be placed here
                indexOfPreviousStall = i;
                noOfCowsOnStall+=1;
                if(noOfCowsOnStall>=k) break;
            }
        }
        return noOfCowsOnStall>=k;
    }
}

Coco eating banana

Prashant Mishra — Sun, 14 Jun 2026 14:32:33 +0000

Coco Eating banana

class Solution {
    public int minEatingSpeed(int[] piles, int h) {
        int min = 1;//Atleast one banana coco can eat
        int max = Integer.MIN_VALUE;//max would be the max value in the piles[] array

        for(int i =0;i< piles.length;i++){
            max = Math.max(max, piles[i]);
        }
        int result = Integer.MAX_VALUE;
        while(min<=max){
            int mid  = (min+max)/2;
            if(possible(mid,piles,h)){//if this is possible then there could be smaller value of k that is also possible
                result = Math.min(result, mid);
                max =  mid-1;
            }
            else min = mid+1;
        }
        return result;

    }
    public boolean possible (int k, int piles[] , int h){
        long time  =0;
        for(int p : piles){
            time+=p/k;
            if(p%k!=0) time++;
        }

        return time<=h;
    }
}

Aggressive Cows

#binarysearch #dsa #gfg

1 min read

Prashant Mishra

Jun 17

Allocate minimum pages

#leetcode #java #dsa #binarysearch

1 min read

Prashant Mishra

Jun 22

Minimize max distance to gas station

#binary #seach #leetcode #dsa

1 min read

Count Inversion using merge sort

Prashant Mishra — Sat, 13 Jun 2026 14:52:35 +0000

Count Inversion

class Solution {
    static int inversionCount(int arr[]) {
        // Code Here
        return merge(0, arr.length-1, arr);

    }
    public static int merge(int i , int j, int nums[]){
    int count =0;
    if(i<j){
        int m = (i+j)/2;
        count+=merge(i,m,nums);
        count+=merge(m+1,j,nums);
        count+=sort(i,m,j,nums);
    }
    return count;

    }
    public static int sort(int i , int k, int j, int arr[]){
        int count =0;
        int a[]  =new int[k-i+1];
        int b[] = new int[j-k];//j-(k+1) + 1

        for(int p=0;p<a.length;p++){
            a[p] = arr[p+i];
        }
        for(int q = 0;q<b.length;q++){
            b[q] = arr[q+k+1];
        }


        int p = 0;
        int q = 0;
        int r = i;
        while(p<a.length && q<b.length){
            if(a[p]<=b[q]){
                arr[r] = a[p];
                p++;
            }
            else{
                arr[r] = b[q];
                count+=a.length-p;
                q++;
            }
            r++;
        }

        while(p<a.length){
            arr[r] = a[p];
            r++;
            p++;
        }
        while(q<b.length){
            arr[r] = b[q];
            r++;
            q++;
        }

        return count;
    }
}

Algo: Binary Search

Prashant Mishra — Sun, 03 May 2026 13:03:10 +0000

Example: Search in rotated sorted array II

class Solution {
    public boolean search(int[] nums, int target) {
        int left = 0;
        int right = nums.length-1;
        while(left<=right){
            int mid = (left+right)/2;
            if(target==nums[mid]) return true;
            if(nums[left]==nums[mid] && nums[mid] == nums[right]){
                left++;
                right--;
                continue;
            }
            if(nums[left]<=nums[mid]){
               if(target<nums[mid] && target>=nums[left]) right = mid-1;
               else left=  mid+1;
            }
            else {
                if(target > nums[mid] && target<= nums[right]) left = mid+1;
                else right =  mid-1;
            }

        }
        return false;
    }
}

Pattern: Permutations

Prashant Mishra — Sun, 03 May 2026 10:06:39 +0000

A Permutations is rearrangement of all the elements of the array.
Example:
Permutations

class Solution {
    List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        int taken[] = new int[nums.length];
        permute(nums, taken, new ArrayList<>());
        return list;
    }
    public void permute(int nums[], int [] taken, List<Integer> l){
        if(l.size()== nums.length){
            list.add(new ArrayList<>(l));
            return;
        }
        for(int i = 0;i< nums.length;i++){
            if(i>0 && nums[i]==nums[i-1] && taken[i-1]==1) continue;
            if(taken[i]==0){
                taken[i] = 1;
                l.add(nums[i]);
                permute(nums,taken,l);
                l.remove(l.size()-1);
                taken[i]=0;
            }
        }
    }
}

Example 2: Permutation II - get unique permutations

class Solution {
    List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        int taken[] = new int[nums.length];
        permute(nums, taken, new ArrayList<>());
        return list;  
    }
    public void permute(int nums[], int [] taken, List<Integer> l){
        if(l.size()== nums.length){
            list.add(new ArrayList<>(l));
            return;
        }
        for(int i = 0;i< nums.length;i++){
            //If previous duplicate is NOT used → skip current
            if(i>0 && nums[i]==nums[i-1] && taken[i-1]==0) continue;
            if(taken[i]==0){
                taken[i] = 1;
                l.add(nums[i]);
                permute(nums,taken,l);
                l.remove(l.size()-1);
                taken[i]=0;
            }
        }
    }
}

Pattern: DFS Algo

Prashant Mishra — Wed, 29 Apr 2026 16:54:52 +0000

Used in graph traversal where you visit all the nodes at the same level then go on visiting nodes in the next level
E.g. Shortest path in binary matrix

class Solution {
    public int shortestPathBinaryMatrix(int[][] grid) {
        if(grid[0][0]!=0) return -1;
        Queue<Node> q  = new LinkedList<>();
        int dirs[][] = {{0,-1},{0,1},{-1,0},{1,0},{1,1},{-1,-1},{-1,1},{1,-1}};
        q.add(new Node(0,0,1)); // stating point (0,0) with distance 1
        int visited[][] = new int[grid.length][grid[0].length];
        for(int vis[]: visited){
            Arrays.fill(vis, -1);
        }

        while(!q.isEmpty()){
            Node n = q.remove();
            int I = n.i;
            int J = n.j;
            int D = n.d;
            if(I == grid.length-1 && J == grid[0].length-1) return D;
            for(int dir[]: dirs){
                int i = dir[0] + I;
                int j = dir[1] + J;
                if(i<grid.length && j<grid[0].length && i>=0 && j>=0 && grid[i][j] ==0 && visited[i][j]==-1){
                    visited[i][j] = 1;
                    q.add(new Node(i,j, D+1));
                }
            }
        }
        return -1;
    }
}
class Node{
    int i;
    int j;
    int d;
    public Node(int i, int j, int d){
        this.i  =i;
        this.j = j;
        this.d = d;
    }
}

Solved using Dijkstra's single source shortest path- it is Not recommended as it is not that efficient in this case as each step has weight i.e 1

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;
    }
}