Stack Problem Solving: Conditional Processing and String Repeat

🚀 Day 10 – LeetCode Practice Today, I solved the First Missing Positive problem on LeetCode: 🎯 Difficulty: Hard 💻 Language Used: Java 💡 Approach: • Given an unsorted integer array, the task was to find the smallest missing positive integer in O(n) time and O(1) extra space. • I used an index hashing technique by placing each positive number n at index n–1. • After rearranging in-place, the first position where the value doesn’t match the index+1 is the answer. • If all positions are correct, the missing positive is length + 1. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 📚 Key Takeaway: This problem reinforced how careful in-place rearrangement + index mapping can eliminate the need for extra data structures while achieving linear time — a powerful pattern for optimized solutions. Consistent problem-solving practice continues to strengthen my algorithmic intuition and implementation skills. 💪 #LeetCode #Java #DSA #Arrays #IndexHashing #ProblemSolving #Algorithms #CodingPractice #100DaysOfCode #SoftwareDeveloper

📌 LeetCode Daily Challenge — Day 3 Problem: 1545. Find Kth Bit in Nth Binary String Topic: String, Recursion, Divide and Conquer 🧠 Approach (Simple Thinking): 🔹 Every string Sn is made of 3 parts: The previous string S(n-1) on the left A single "1" sitting right in the middle The flipped and reversed version of S(n-1) on the right 🔹 The string doubles in size every level by S20 you're looking at 1M+ characters. Building it fully? Not a chance. So instead, we recursively figure out which part position k falls into 🔹 If k is in the left half → it behaves exactly like S(n-1). Just recurse with the same k and go one level down 🔹 If k is exactly the middle → no need to recurse at all. The middle is always '1', guaranteed by construction 🔹 If k is in the right half → the right half is a mirror of the left half but with all bits flipped. So we calculate the mirrored position, recurse into the left half to get that bit, and then flip the answer 🔹 Base case → when n = 1, the string is just "0". Return it and start unwinding ⏱️ Time Complexity: Recurse at most n levels deep → O(n) n = the level of the binary string 📦 Space Complexity: Recursive call stack depth is n → O(n) No extra arrays or data structures created 📝 Put together a full walkthrough covering the approach, dry run, and code explanation. 👉 check it out here: https://lnkd.in/gGrReU9W Got a different way to tackle this? Always curious to see alternate approaches share it in the comments below! 🙌 Until the next one, happy coding! 🚀 #LeetCode #Java #SoftwareEngineer #ProblemSolving #BackendDeveloper

🚀 Day 3 – LeetCode Practice Today, I solved the 3Sum problem on LeetCode: 🎯 Difficulty: Medium/Hard 💻 Language Used: Java 💡 Approach: • Given an integer array nums, the objective was to find all unique triplets that sum up to zero. • I sorted the array first to simplify searching and avoid duplicates. • Used a fixed pointer + two-pointer technique: – For each element (as the first of the triplet), used two pointers to find pairs that complete the sum to zero. • To avoid duplicate triplets, I skipped repeated values during iteration. ⏱ Complexity: • Time Complexity: O(n²) • Space Complexity: O(1) (excluding output list) 📚 Key Takeaway: This problem strengthened my understanding of sorting combined with two-pointer strategies to reduce brute-force complexity. Handling duplicates correctly was also key to returning unique triplets. Consistent problem-solving practice continues to improve my algorithmic thinking and confidence in handling array-based challenges. 💪 #LeetCode #Java #DSA #TwoPointers #Arrays #ProblemSolving #Algorithms #100DaysOfCode #SoftwareDeveloper

🚀 Day 6 – LeetCode Practice Today, I solved the Find the Index of the First Occurrence in a String problem on LeetCode: 🎯 Difficulty: Easy 💻 Language Used: Java 💡 Approach: • Given two strings haystack and needle, the task was to find the first position where needle appears in haystack. • I used a sliding window / two-pointer technique to compare substrings efficiently. • Iterated through haystack and checked each potential starting position for a substring match with needle. • Returned the starting index of the first match, or -1 if not found. ⏱ Complexity: • Time Complexity: O(n × m) (where n = length of haystack, m = length of needle) • Space Complexity: O(1) 📚 Key Takeaway: This problem refreshed fundamental string traversal and comparison logic. Efficient substring searches are foundational to text processing and pattern matching tasks. Consistent problem-solving practice continues to strengthen my confidence and coding fundamentals. 💪 #LeetCode #Java #DSA #Strings #ProblemSolving #Algorithms #CodingPractice #100DaysOfCode #SoftwareDeveloper

Day 6 — this problem broke my brain until I thought about it like a chef cutting a sandwich. 🧠 LeetCode 241 — Different Ways to Add Parentheses The problem: Given an expression, return ALL possible results from every different way to place parentheses. 2-1-1 → [0, 2] — same numbers, different brackets, different answers. The insight 💡 Every operator is a potential "last operation." Split there. Solve left. Solve right. Combine every result from both sides. Repeat recursively for every operator. That's it. Divide and Conquer. "2*3-4*5" Split at * → left:"2", right:"3-4*5" Split at - → left:"2*3", right:"4*5" Split at * → left:"2*3-4", right:"5" ... combine all results → [-34,-14,-10,-10,10] Why recursion fits perfectly here: Smaller subexpressions have the same structure as the original. Classic D&C pattern — break, solve, merge. Real world connection 🔗 This is exactly how compilers build Abstract Syntax Trees. Every operator is a split point. Every subexpression becomes a subtree. Day 6 done. Streak alive. 💪 #DSA #LeetCode #Java #DivideAndConquer #Recursion #100DaysOfCode #BackendDeveloper #CompetitiveProgramming

🚀 Day 8 – LeetCode Practice Today, I solved the Search Insert Position problem on LeetCode: 🎯 Difficulty: Easy 💻 Language Used: Java 💡 Approach: • Given a sorted array and a target value, the task was to return the index where the target should be inserted if it is not found. • I used an efficient binary search approach to locate the correct position in O(log n) time. • If the target exists, return its index; otherwise, return the index where it would be inserted to maintain sorted order. ⏱ Complexity: • Time Complexity: O(log n) • Space Complexity: O(1) 📚 Key Takeaway: This problem reinforced how binary search can be slightly adapted to both find and insert positions in a sorted array without scanning the entire list — an essential optimization in sorted data structures. Consistent problem-solving practice continues to build intuition for time-efficient algorithms and clean implementations. 💪 #LeetCode #Java #DSA #BinarySearch #Algorithms #ProblemSolving #CodingPractice #100DaysOfCode #SoftwareDeveloper

🚀 DAY 60/150 — DECODING STRINGS WITH STACK! 🚀 Day 60 of my 150 Days DSA Challenge in Java and today I solved an interesting problem involving nested patterns and stack-based decoding 💻🧠 Reaching Day 60 feels great because this journey is not only improving my problem-solving skills but also helping me understand different data structures and patterns. 📌 Problem Solved: Decode String 📌 LeetCode: #394 📌 Difficulty: Medium The task is to decode an encoded string where patterns follow the format: k[encoded_string] This means the substring inside the brackets must be repeated k times. Example: 3[a2[c]] → accaccacc Approach Used To solve this efficiently, I used the Stack data structure. • Traverse the string character by character • When encountering a number → build the repeat count • When encountering [ → push the current string and count onto the stack • When encountering ] → pop from the stack and repeat the substring accordingly This helps handle nested encoded patterns effectively. Key Learnings • Stack is very useful for handling nested structures • Maintaining both the current string and repeat count is essential • Breaking complex strings into smaller manageable segments simplifies the logic What I Learned From This Problem • Problems involving nested patterns often require stack-based solutions • Careful string construction helps avoid unnecessary complexity • Understanding how to manage intermediate states is key in decoding problems This problem strengthened my understanding of Stack operations and nested pattern parsing 🚀 ✅ Day 60 completed 🚀 90 days to go 🔗 Java Solution on GitHub: 👉 https://lnkd.in/gxTGAqnJ 💡 Stack helps simplify problems involving nested patterns and sequential decoding. #DSAChallenge #Java #LeetCode #Stack #DecodeString #150DaysOfCode #ProblemSolving #CodingJourney #InterviewPrep #LearningInPublic

🚀 Day 4 – LeetCode Practice Today, I solved the 4Sum problem on LeetCode: 🎯 Difficulty: Medium 💻 Language Used: Java 💡 Approach: • Given an integer array nums and a target value, the goal was to find all unique quadruplets that sum up to the target. • I started by sorting the array to simplify searching and handling duplicates. • Used a nested loop structure with a two-pointer technique for the inner pair search: – The first two pointers fixes the first two elements, and the two pointers inside find matching pairs. • Skipped duplicates carefully to ensure unique quadruplets in the final list. ⏱ Complexity: • Time Complexity: O(n³) • Space Complexity: O(1) (excluding result storage) 📚 Key Takeaway: This problem strengthened my understanding of multi-pointer techniques, careful duplicate handling, and how sorting can significantly simplify complex combination searches. Consistent problem-solving practice continues to build my algorithmic intuition and coding confidence. 💪 #LeetCode #Java #DSA #TwoPointers #Sorting #ProblemSolving #Algorithms #100DaysOfCode #SoftwareDeveloper

🚀 Day 6 – LeetCode Practice Today, I solved the Remove Element problem on LeetCode: 🎯 Difficulty: Easy 💻 Language Used: Java 💡 Approach: • Given an integer array nums and a value val, the task was to remove all occurrences of val in-place and return the new length. • I used the two-pointer technique: – One pointer (slow) tracked where to place the next non-val element. – The other pointer (fast) scanned the array from left to right. • When the current element wasn’t equal to val, I copied it to slow and advanced both pointers. • This ensured we overwrote unwanted values and kept the rest in place without extra space. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 📚 Key Takeaway: This problem reinforced in-place modification and efficient array traversal with minimal space. Simple pointer strategies often help optimize brute-force approaches. Consistent problem-solving practice continues to strengthen my fundamentals and coding clarity. 💪 #LeetCode #Java #DSA #TwoPointers #Arrays #ProblemSolving #Algorithms #100DaysOfCode #SoftwareDeveloper

🚀 Day 10 – LeetCode Practice Today, I solved the Multiply Strings problem on LeetCode: 🎯 Difficulty: Medium 💻 Language Used: Java 💡 Approach: • Given two non-negative integer strings num1 and num2, the task was to return their product as a string without using built-in large number libraries. • I simulated digit-by-digit multiplication similar to how we multiply numbers on paper: – Reversed both strings and multiplied each digit pair. – Stored intermediate results in a result array and used carry propagation. – Finally built the resulting string by trimming leading zeros. ⏱ Complexity: • Time Complexity: O(n × m) (where n and m are lengths of num1 and num2) • Space Complexity: O(n + m) 📚 Key Takeaway: This problem strengthened my understanding of number manipulation at the string level and how to implement arithmetic logic without relying on built-in big integer functions — a useful technique for handling large numeric inputs. Consistent problem-solving practice continues to build my algorithmic intuition and implementation skills. 💪 #LeetCode #Java #DSA #Strings #Algorithms #ProblemSolving #CodingPractice #100DaysOfCode #SoftwareDeveloper