Supriya Singh’s Post

𝗗𝗮𝘆 𝟳/𝟮𝟬 — 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲 𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲🎯 Solved Longest Valid Parentheses ➤ Problem: Given a string of ‘(’ and ‘)’, determine the length of the longest well-formed (valid) parentheses substring. ➤ Approach: Used a clean and structured stack-based technique to identify valid boundaries efficiently. • Initialize the stack with -1 as the base index. • Push every '(' index onto the stack. • On encountering ')', pop to attempt a match. • If the stack becomes empty, push the current index as the new starting point. • Otherwise, compute the valid substring length using currentIndex − stackTop. Continuously update the maximum length. This ensures each character is processed in a single pass, maintaining optimal efficiency. #LeetCode #Java #DSA #TwoPointers #ArrayManipulation #ProblemSolving #20DaysChallenge #Consistency

After permutations, I worked on generating binary strings without consecutive 1s. This problem introduced something important — constraint control. Instead of blindly generating all combinations, I had to prevent invalid states during recursion itself. What became clear here: - Recursion trees can be pruned early. - Constraints should be checked before making the next call. - Smart branching reduces unnecessary work. - Not all recursion problems require exploring every path. Core logic : if (n == 0) {   System.out.println(current);   return; } binary(n - 1, current + "0"); if (lastChar != '1') {   binary(n - 1, current + "1"); } This was different from earlier problems. Now recursion wasn’t just exploring — it was filtering while exploring. That control makes a big difference in efficiency. #recursion #java #dsajourney #backtracking #problemSolving

Day 28 - Maximum Subarray Implemented a linear-time dynamic approach to compute the maximum contiguous subarray sum. Maintained: sum→ best subarray ending at current index maxsum → global maximum Reset accumulation when extending the previous segment becomes suboptimal. Achieved optimal O(n) time with constant space. #Day28 #ProblemSolving #Algorithms #InterviewPrep #Java

Day - 86 Binary Tree Preorder Traversal The problem - Given the root of a binary tree, return the preorder traversal of its nodes' values. In preorder traversal, we visit nodes in the order: Root → Left → Right. Brute Force - Store all nodes in an array using level-order traversal, then manually rearrange them in preorder sequence. This gives O(n²) time complexity due to repeated searching and rearranging, which is highly inefficient. Approach Used - •) Initialize ans = new ArrayList<>(). •) If root == null, return empty ans. •) Call helper function - preorder(root, ans). •) Return ans. Helper Function - •) If root != null, 1 - Add current node value: ans.add(root.val). 2 - Recursively traverse left subtree, preorder(root.left, ans). 3 - Recursively traverse right subtree, preorder(root.right, ans). Complexity - Time - O(n), where n = number of nodes. Space - O(h), where h = height of tree. Note - Preorder traversal naturally follows a recursive pattern: process the current node (Root), then recursively process the left subtree (Left), and finally the right subtree (Right). The recursion stack implicitly handles backtracking, making the implementation clean and straightforward. #DSA #Java #SoftwareEngineering #InterviewPrep #LearnToCode #CodeDaily #ProblemSolving

Day 25 - Search Insert Position Technique Used: Binary Search Key Idea: Applied binary search to locate the target in a sorted array. If the target is not found, returned the index where it would be inserted while maintaining sorted order. The final start pointer represents the correct insertion position. Time Complexity: O(log n) #Day25 #LeetCode #Java #BinarySearch #DSA #Algorithms

Day 26 - Single Element in a Sorted Array Technique Used: Parity-Based Binary Search Key Idea: Since every element appears twice except one, used index parity (even/odd positions) to determine which half violates the pairing rule. If pairing is correct on the left side, move right. Otherwise, move left. Time Complexity: O(log n) #Day26 #LeetCode #Java #BinarySearch #DSA #Algorithms

Transformed Array: Leetcode Problem link:https://lnkd.in/gHFR9qwp Idea: For every index i, the value nums[i] tells me where to move next. If nums[i] == 0 → no movement, so result[i] = nums[i] If nums[i] > 0 → move right nums[i] steps (wrapping from last index back to 0) If nums[i] < 0 → move left abs(nums[i]) steps (wrapping from 0 back to last index) How I implemented it: I loop through each index i. I call a helper method moveIndex(n, i, shift) which moves one step at a time: right if shift is positive left if shift is negative wraps around at the edges Once I get the newIndex, I set: result[i] = nums[newIndex] #Java #DSA #Algorithms #ProblemSolving #CleanCode #CodingInterview #BackendEngineering

💡 Detecting Duplicates using Insertion Sort Logic (No Extra Space!) Instead of using HashSet or extra memory, I tried a different approach — modifying Insertion Sort. 👉 Idea: Assume the left part of the array is already sorted. When inserting the next element (key), we shift bigger elements right. During shifting: If we meet an element equal to the key → Duplicate found immediately If smaller → insert at correct position In simple words: Keep shifting while elements are bigger If equal → duplicate If smaller → insert 📊 Complexity: • Worst Case: O(n²) • Space: O(1) • Early exit if duplicate appears Nice reminder that sometimes classic sorting logic can double as a searching technique! #DSA #Java #Algorithms #ProblemSolving #CodingInterview

Day 13 of Daily DSA 🚀 Solved LeetCode 33: Search in Rotated Sorted Array ✅ Approach: Used modified Binary Search to handle rotation efficiently. At each step, identified the sorted half of the array and checked whether the target lies within that range. Based on this, adjusted the search boundaries to maintain logarithmic performance. This problem is a great example of how classic binary search logic can be extended with small observations. ⏱ Complexity: • Time: O(log n) • Space: O(1) 📊 LeetCode Stats: • Runtime: 0 ms (Beats 100%) ⚡ • Memory: 43.97 MB (Beats 45.43%) #DSA #LeetCode #Java #BinarySearch #ProblemSolving #DailyCoding #Consistency

LeetCode Problem Solved | #739 : Daily Temperatures Today I solved 739. Daily Temperatures - a classic problem that beautifully demonstrates the power of the Monotonic Stack pattern. 🧩 Problem Summary Given an array of daily temperatures, return an array such that for each day, you tell how many days you have to wait until a warmer temperature. If there is no future warmer day, return 0 for that day. Example: Input: [73,74,75,71,69,72,76,73] Output: [1,1,4,2,1,1,0,0] 💡 Solution approach : ✔ Store indices (not temperatures). ✔ Maintain decreasing order of temperatures in the stack. ✔ When a warmer temperature appears, pop elements and calculate the difference in indices. 💻 I’ve added my Java solution in the comments below. #LeetCode #DataStructures #Java #MonotonicStack #DSA #ProblemSolving #Stack