LeetCode 761: Special Binary String Solution

🚀 Day 10 – LeetCode Practice Today, I solved the Trapping Rain Water problem on LeetCode: 🎯 Difficulty: Hard 💻 Language Used: Java 💡 Approach: • Given an elevation map represented by an array, the task was to determine how much rainwater can be trapped after raining. • I used a two-pointer technique with left & right pointers moving inward: – Tracked max height from both ends (leftMax, rightMax). – At each step, water trapped is based on the smaller max height minus current height. – Moving pointers inward ensures efficient calculation in one pass. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 📚 Key Takeaway: This problem reinforced how two-pointer strategies can optimize otherwise naïve solutions and how keeping track of boundary conditions leads to efficient space-constant algorithms. Consistent problem-solving practice continues to strengthen my algorithmic intuition and implementation skills. 💪 #LeetCode #Java #DSA #TwoPointers #Algorithms #ProblemSolving #CodingPractice #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 18 of #75DaysOfLeetCode 🚴♂️ LeetCode Problem Solved: Find the Highest Altitude (1732) Today I solved “Find the Highest Altitude” on LeetCode. This problem focuses on understanding prefix sum logic and cumulative calculations. 🔹 Problem Summary: A biker starts a road trip at altitude 0. We are given an array gain, where each value represents the net change in altitude between consecutive points. The goal is to determine the highest altitude reached during the trip. 🔹 Key Idea: Start with altitude 0, keep adding the gains step by step, and track the maximum altitude reached during the journey. 💻 Java Solution: class Solution { public int largestAltitude(int[] gain) { int currentAltitude = 0; int maxAltitude = 0; for (int g : gain) { currentAltitude += g; maxAltitude = Math.max(maxAltitude, currentAltitude); } return maxAltitude; } } 📌 Concepts Used: • Prefix Sum • Array Traversal • Basic Simulation ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) Consistently practicing problems like these helps strengthen problem-solving and algorithmic thinking. #LeetCode #Java #DataStructures #Algorithms #ProblemSolving #CodingJourney #Programming

🚀 Day 5 – LeetCode Practice Today, I solved the Reverse Nodes in k-Group problem on LeetCode: 🎯 Difficulty: Hard 💻 Language Used: Java 💡 Approach: • Given a linked list and an integer k, the task was to reverse every group of k nodes. • I used pointer manipulation and a dummy node to handle group reversals cleanly. • Moved through the list in blocks of k, reversing each sub-group by re-wiring next pointers. • Ensured that if the final group had fewer than k nodes, it was kept as-is. • This approach ensured in-place reversal without extra space. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 📚 Key Takeaway: This problem deepened my understanding of in-place linked list manipulation, group operations, and edge-case handling when list length isn’t a multiple of k. Solving pattern-rich, hard problems like this consistently improves my algorithmic thinking and implementation precision. 💪 #LeetCode #Java #DSA #LinkedList #ProblemSolving #Algorithms #CodingPractice #100DaysOfCode #SoftwareDeveloper

🚀 Day 4 – LeetCode Practice Today, I solved the Letter Combinations of a Phone Number problem on LeetCode: 🎯 Difficulty: Medium 💻 Language Used: Java 💡 Approach: • Given a string of digits from 2–9, the goal was to return all possible letter combinations mapped to those digits (like on a phone keypad). • I used a backtracking technique to explore all potential combinations recursively. • Mapped digits to corresponding letters and built combinations character by character. • Backtracking quickly pruned paths and ensured all valid combinations were explored. ⏱ Complexity: • Time Complexity: O(3ⁿ × 4ᵐ) (Where n is the count of digits mapping to 3 letters and m to 4 letters) • Space Complexity: O(L) (for the combination path stack) 📚 Key Takeaway: This problem reinforced recursive backtracking as an efficient strategy for exploring combinatorial possibilities. Practicing such techniques strengthens both recursion skills and pattern exploration logic. Consistent problem-solving practice continues to improve my confidence and coding fundamentals. 💪 #LeetCode #Java #DSA #Backtracking #Algorithms #ProblemSolving #100DaysOfCode #SoftwareDeveloper

🚀 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 7 – LeetCode Practice Today, I solved the Longest Valid Parentheses problem on LeetCode: 🎯 Difficulty: Hard 💻 Language Used: Java 💡 Approach: • Given a string containing just '(' and ')', the task was to find the length of the longest valid (well-formed) parentheses substring. • I used an efficient stack-based approach to keep track of indices, which helps in identifying valid matching pairs. • By saving indices of unmatched parentheses and computing differences when matches occur, I found the longest valid length. • This technique handles nested and overlapped valid segments seamlessly. ⏱ Complexity: • Time Complexity: O(n) • Space Complexity: O(n) 📚 Key Takeaway: This problem strengthened my understanding of stack usage for string matching and taught how index tracking can help solve complex substring problems efficiently. Consistent problem-solving practice continues to build my algorithmic intuition and implementation confidence. 💪 #LeetCode #Java #DSA #Stack #ProblemSolving #Algorithms #CodingPractice #100DaysOfCode #SoftwareDeveloper

🚀 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 8 – LeetCode Practice Today, I solved the Count and Say problem on LeetCode: 🎯 Difficulty: Easy / Medium 💻 Language Used: Java 💡 Approach: • The “count and say” sequence is built by reading off digits of the previous term — counting repeated digits then describing them. • I started from the base term "1" and iteratively built the next term by scanning the current string and describing consecutive runs of the same character. • This continues until the nth term is generated. ⏱ Complexity: • Time Complexity: O(n × k) (n = sequence length, k = average term length) • Space Complexity: O(k) 📚 Key Takeaway: This problem improved my understanding of string manipulation and iterative pattern construction. Carefully building and transforming sequences is a useful technique in many real-world problems. Consistent problem-solving practice continues to strengthen my logic and coding confidence 💪 #LeetCode #Java #DSA #Strings #ProblemSolving #Algorithms #CodingPractice #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