DEV Community: Debesh P.

21. Merge Two Sorted Lists | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Tue, 17 Feb 2026 19:53:50 +0000

Problem Link

https://leetcode.com/problems/merge-two-sorted-lists/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/merge-two-sorted-lists/solutions/7587317/beats-1000-step-by-step-explanation-all-bkmtk

Solution

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {

        ListNode result = new ListNode(0);
        ListNode ptr = result;

        while (list1 != null && list2 != null) {
            if (list1.val <= list2.val) {
                ptr.next = list1;
                list1 = list1.next;
            } else {
                ptr.next = list2;
                list2 = list2.next;
            }
            ptr = ptr.next;
        }

        if (list1 == null) ptr.next = list2;
        if (list2 == null) ptr.next = list1;

        return result.next;
    }
}

2. Add Two Numbers | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Mon, 16 Feb 2026 20:02:14 +0000

Problem Link

https://leetcode.com/problems/add-two-numbers/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/add-two-numbers/solutions/7584850/beats-200-all-languages-using-linkedlist-nf53

Solution

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

        ListNode result = new ListNode(0);
        ListNode ptr = result;
        int carry = 0;

        while (l1 != null || l2 != null) {
            int sum = 0 + carry;

            if (l1 != null) {
                sum += l1.val;
                l1 = l1.next;
            }

            if (l2 != null) {
                sum += l2.val;
                l2 = l2.next;
            }

            carry = sum / 10;
            sum = sum % 10;
            ptr.next = new ListNode(sum);
            ptr = ptr.next;
        }

        if (carry == 1) ptr.next = new ListNode(1);
        return result.next;
    }
}

141. Linked List Cycle | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Sun, 15 Feb 2026 19:24:56 +0000

Problem Link

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

Detailed Step-by-Step Explanation

https://leetcode.com/problems/linked-list-cycle/solutions/7582225/beats-200-floyds-cycle-detection-tortois-1vng

Solution

public class Solution {
    public boolean hasCycle(ListNode head) {

        ListNode slowPtr = head;
        ListNode fastPtr = head;

        while (slowPtr != null && fastPtr != null && fastPtr.next != null) {
            slowPtr = slowPtr.next;
            fastPtr = fastPtr.next.next;

            if (slowPtr == fastPtr) {
                return true;
            }
        }

        return false;
    }
}

224. Basic Calculator | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Fri, 13 Feb 2026 16:58:06 +0000

Problem Link

https://leetcode.com/problems/basic-calculator/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/basic-calculator/solutions/7576826/most-optimal-beats-100-all-languages-sta-jd4n

Solution

class Solution {
    public int calculate(String s) {

        Stack<Integer> stack = new Stack<>();

        int res = 0;
        int curr = 0;
        int sign = 1;

        for (char c : s.toCharArray()) {
            if (Character.isDigit(c)) {
                curr = curr * 10 + (c - '0');
            } else if (c == '+') {
                res += curr * sign;
                sign = 1;
                curr = 0;
            } else if (c == '-') {
                res += curr * sign;
                sign = -1;
                curr = 0;
            } else if (c == '(') {
                stack.push(res);
                stack.push(sign);
                res = 0;
                sign = 1;
                curr = 0;
            } else if (c == ')') {
                res += curr * sign;
                curr = 0;
                res *= stack.pop();
                res += stack.pop();
            }
        }

        res += sign * curr;
        return res;
    }
}

150. Evaluate Reverse Polish Notation | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Wed, 11 Feb 2026 19:19:57 +0000

Problem Link

https://leetcode.com/problems/evaluate-reverse-polish-notation/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/evaluate-reverse-polish-notation/solutions/7572013/most-optimal-solution-beats-500-stack-al-nrde

Solution

class Solution {
    public int evalRPN(String[] tokens) {

        Stack<Integer> stack = new Stack<>();

        for (String token : tokens) {
            if (token.equals("+") || token.equals("-") ||
                token.equals("*") || token.equals("/")) {
                int b = stack.pop();
                int a = stack.pop();
                int res = operate(a, b, token);
                stack.push(res);
            } else {
                stack.push(Integer.parseInt(token));
            }
        }

        return stack.pop();
    }

    private int operate(int a, int b, String token) {
        switch (token) {
            case "+" : return a + b;
            case "-" : return a - b;
            case "*" : return a * b;
            case "/" : return a / b;
            default : return 0;
        }
    }
}

155. Min Stack | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Tue, 10 Feb 2026 09:13:44 +0000

Problem Link

https://leetcode.com/problems/min-stack/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/min-stack/solutions/7568000/most-optimal-code-beats-200-all-language-2flu

Solution

class MinStack {

    Stack<Integer> stack;
    Stack<Integer> minStack;

    public MinStack() {
        stack = new Stack<>();
        minStack = new Stack<>();
    }

    public void push(int val) {
        stack.push(val);
        if(minStack.isEmpty() || val <= minStack.peek()) {
            minStack.push(val);
        }
    }

    public void pop() {
        int poppedVal = stack.pop();
        if(poppedVal == minStack.peek()) {
            minStack.pop();
        }
    }

    public int top() {
        return stack.peek();
    }

    public int getMin() {
        return minStack.peek();
    }
}

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(val);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

71. Simplify Path | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Mon, 09 Feb 2026 19:52:14 +0000

Problem Link

https://leetcode.com/problems/simplify-path/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/simplify-path/solutions/7566828/optimal-solution-beats-100-multiple-lang-lf3h

Solution

class Solution {
    public String simplifyPath(String path) {

        Stack<String> st = new Stack<>();
        String[] components = path.split("/");

        for (String component : components) {

            if (component.equals("") || component.equals(".")) {
                continue;
            }

            if (component.equals("..")) {
                if (!st.isEmpty()) {
                    st.pop();
                }
            } else {
                st.push(component);
            }
        }

        if (st.isEmpty()) {
            return "/";
        }

        StringBuilder res = new StringBuilder();
        for (String dir : st) {
            res.append("/").append(dir);
        }

        return res.toString();
    }
}

20. Valid Parentheses | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Sat, 07 Feb 2026 07:45:54 +0000

Problem Link

https://leetcode.com/problems/valid-parentheses/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/valid-parentheses/solutions/7559664/most-optimal-solution-beats-100-all-lang-32y5

Solution

class Solution {
    public boolean isValid(String s) {

        Stack<Character> stack = new Stack<>();

        for (char c : s.toCharArray()) {

            if (c == '(') {
                stack.push(')');
            } 
            else if (c == '{') {
                stack.push('}');
            } 
            else if (c == '[') {
                stack.push(']');
            } 
            else {
                if (stack.isEmpty() || stack.pop() != c) {
                    return false;
                }
            }
        }

        return stack.isEmpty();
    }
}

452. Minimum Number of Arrows to Burst Balloons | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Sat, 31 Jan 2026 21:15:45 +0000

Problem Link

https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/solutions/7540732/most-optimal-solution-all-languages-avai-47ic

Solution

class Solution {
    public int findMinArrowShots(int[][] points) {

        int n = points.length;
        if (n == 0) return 0;
        Arrays.sort(points, (a, b) -> Integer.compare(a[1], b[1]));

        int arrows = 1;
        int end = points[0][1];

        for (int i = 1; i < n; i++) {
            if (points[i][0] > end) {
                arrows++;
                end = points[i][1];
            }
        }

        return arrows;
    }
}

57. Insert Interval | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Fri, 23 Jan 2026 17:36:23 +0000

Problem Link

https://leetcode.com/problems/insert-interval/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/insert-interval/solutions/7518330/most-optimal-solution-all-languages-beat-jp9b

Solution

class Solution {
    public int[][] insert(int[][] intervals, int[] newInterval) {

        List<int[]> res = new ArrayList<>();
        int i = 0;

        while (i < intervals.length && intervals[i][1] < newInterval[0]) {
            res.add(intervals[i]);
            i++;
        }

        while (i < intervals.length && intervals[i][0] <= newInterval[1]) {
            newInterval[0] = Math.min(newInterval[0], intervals[i][0]);
            newInterval[1] = Math.max(newInterval[1], intervals[i][1]);
            i++;
        }
        res.add(newInterval);

        while (i < intervals.length) {
            res.add(intervals[i]);
            i++;
        }

        return res.toArray(new int[res.size()][]);
    }
}

56. Merge Intervals | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Wed, 21 Jan 2026 18:03:10 +0000

Problem Link

https://leetcode.com/problems/merge-intervals/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/merge-intervals/solutions/7513395/most-optimal-solution-beats-200-all-lang-wtea

Solution

class Solution {
    public int[][] merge(int[][] intervals) {

        if (intervals.length <= 1) {
            return intervals;
        }

        Arrays.sort(intervals, Comparator.comparingInt(i -> i[0]));

        List<int[]> res = new ArrayList<>();

        int[] current = intervals[0];
        res.add(current);

        for (int[] interval : intervals) {
            if (current[1] >= interval[0]) {
                current[1] = Math.max(current[1], interval[1]);
            } else {
                current = interval;
                res.add(current);
            }
        }

        return res.toArray(new int[res.size()][]);
    }
}

228. Summary Ranges | LeetCode | Top Interview 150 | Coding Questions

Debesh P. — Tue, 20 Jan 2026 18:20:32 +0000

Problem Link

https://leetcode.com/problems/summary-ranges/

Detailed Step-by-Step Explanation

https://leetcode.com/problems/summary-ranges/solutions/7510743/most-optimal-solution-beats-200-on-o1-in-5huw

Solution

class Solution {
    public List<String> summaryRanges(int[] nums) {

        List<String> res = new ArrayList<>();
        int n = nums.length;

        for (int i = 0; i < n; i++) {
            int start = nums[i];

            while (i + 1 < n && nums[i + 1] - nums[i] == 1) {
                i++;
            }

            if (start == nums[i]) {
                res.add(String.valueOf(start));
            } else {
                res.add(start + "->" + nums[i]);
            }
        }

        return res;
    }
}