LeetCode Challenge: Alternating Binary String Solution

🚀 Day 93 of #100DaysOfCode Challenge Today’s problem was all about identifying “Beautiful Strings” 🔢✨ A numeric string is called beautiful if: ✔️ It can be split into a sequence of increasing numbers ✔️ Each number is exactly +1 from the previous ✔️ No leading zeros allowed 💡 What I Learned Today: How to break strings into valid sequences Handling large numbers using long long Importance of string comparison vs integer operations Edge cases like: Leading zeros ❌ Single digit strings ❌ Invalid increments ❌ 🧠 Approach: Try all possible starting numbers Generate the sequence dynamically (x, x+1, x+2…) Match the built string with the original If matched → ✅ YES x Else → ❌ NO 💻 Example: 👉 Input: 91011 👉 Output: YES 9 ⚡ Key Takeaway: Sometimes brute force with smart validation is the best approach! 📅 Consistency is the real game changer. On to Day 94 💪 #Coding #Programming #CProgramming #DataStructures #ProblemSolving #100DaysOfCode #DeveloperJourney #LearningEveryday

🚀 Day 182 of #200DaysOfCoding 📌 Problem: Check if Binary String Has at Most One Segment of Ones (LeetCode 1784) Today’s challenge was about checking whether a binary string contains at most one continuous segment of '1's. 🧠 Problem Understanding We are given a binary string s that starts with 1 and contains only 0 and 1. We need to verify that all 1s appear in one contiguous block. ✔ Valid Examples 111000 110 1000 ❌ Invalid Example 1001 → Here, the segment of 1s breaks and appears again later. 💡 Key Idea If we ever encounter 0 followed by 1, it means a new segment of 1s has started, which violates the condition. ⏱ Complexity Time Complexity: O(n) Space Complexity: O(1) Consistent practice like this is helping me strengthen my problem-solving and data structure skills every day. #Day182 #200DaysOfCoding #LeetCode #DSA #Programming #CodingJourney #ProblemSolving

🚀 Day 13/60 — LeetCode Discipline Problem Solved: Contains Duplicate II (Revision) Difficulty: Easy Today’s practice focused on revisiting a classic array problem that blends hashing with a sliding window concept. The goal was to efficiently determine whether duplicate values appear within a specific index range. Instead of checking every possible pair, the approach maintains a moving window of elements using a hash structure, allowing constant-time lookups while traversing the array. 💡 Focus Areas: • Reinforced hash-based lookup techniques • Practiced sliding window with bounded size • Strengthened index-distance reasoning • Improved understanding of time-efficient duplicate detection • Focused on clean and readable implementation Even simple problems can reinforce powerful ideas when approached with discipline and clarity. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #SlidingWindow #HashSet #Arrays #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers

🚀 Day 17/60 — LeetCode Discipline Problem Solved: 4Sum (Revision) Difficulty: Medium Today’s session revisited the classic k-Sum family problem — 4Sum. After solving 2Sum and 3Sum patterns previously, this problem naturally extends the idea by combining sorting with nested iteration and the two-pointer technique to efficiently identify unique quadruplets. The key challenge lies in managing duplicates carefully while keeping the solution efficient and structured. 💡 Focus Areas: • Strengthened k-Sum pattern understanding • Practiced sorting + two-pointer combination • Improved duplicate handling in multi-pointer problems • Reinforced nested iteration optimization • Focused on writing structured and readable code Problems like these highlight how mastering one pattern allows you to scale the same idea to more complex variations. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #TwoPointers #Arrays #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

🚀 19 of #100DaysOfCode Solved LeetCode 1456 – Maximum Number of Vowels in a Substring of Given Length today. 🔍 Approach: Used the Sliding Window Technique to efficiently track the number of vowels in a substring of size k. Instead of recalculating vowels for every substring, we adjust the count as the window slides forward. 💡 Key Idea: Add the new character entering the window. Remove the character leaving the window. Keep track of the maximum vowel count. ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) This approach optimizes the brute-force solution and makes the algorithm scalable for large inputs. Consistent practice is helping me strengthen my problem-solving and data structures fundamentals. #leetcode #dsaalgorithms #slidingwindow #cpp #codingpractice #programming #softwaredevelopment #100daysofcode #developers #techlearning

🚀 Day 180 of #200DaysOfCoding Today I solved “Special Positions in a Binary Matrix” on LeetCode. 🧠 Problem Idea: We are given a binary matrix and need to count positions where the value is 1 and all other elements in the same row and column are 0. Such positions are called special positions. 💡 Approach: Instead of checking the entire row and column every time, we can optimize by: • Counting the number of 1s in each row • Counting the number of 1s in each column • A cell (i, j) is special if: mat[i][j] == 1 rowCount[i] == 1 colCount[j] == 1 This reduces unnecessary checks and keeps the solution efficient. ⏱ Time Complexity: O(m × n) 📦 Space Complexity: O(m + n) 💻 Language Used: C++ Consistency is the real key. Every day of problem solving improves logical thinking and problem-solving ability. Just 20 more days to complete the #200DaysOfCoding challenge! 💪 #leetcode #codingchallenge #programming #cpp #datastructures #algorithms #softwaredevelopment

🚀 Just solved LeetCode 3643 - Reverse Submatrix Today I worked on a really interesting matrix manipulation problem where the goal was to reverse a k×k submatrix efficiently. 💡 Key Insight: Instead of using extra space, I applied a two-pointer approach to swap rows from top to bottom — making the solution clean and optimal. ⚡ What I learned: • In-place matrix transformations • How to optimize nested loops • Importance of visualizing row/column operations 🧠 Complexity: Time → O(k²) Space → O(1) 📌 Small problems like this build strong fundamentals for bigger DSA challenges! 💻 Code + Explanation PPT available on my GitHub 👇 #LeetCode #DSA #CodingJourney #CPlusPlus #ProblemSolving #Tech #Programming #100DaysOfCode

#Day58 Solved: Longest Substring Without Repeating Characters(Leetcode 3) Worked on one of the most asked string problems that really tests problem-solving and optimization skills. Problem: Find the length of the longest substring without repeating characters. Approach: Used the sliding window technique to efficiently track a valid substring. Instead of checking all possible substrings (which is slow), I dynamically adjusted the window: Expanded when characters were unique Shrunk when a duplicate appeared Key Learning: The biggest takeaway was understanding how to maintain a valid window rather than restarting every time a duplicate is found. Complexity: Optimized the solution from O(n²) to O(n) using the right approach. This problem strengthened my understanding of: Sliding Window Two Pointer Technique Optimizing brute force solutions #leetcode #dsa #programming #coding #slidingwindow #problemSolving

🚀 Day 14/60 — LeetCode Discipline Problem Solved: Maximum Number of Vowels in a Substring of Given Length (Revision) Difficulty: Medium Today’s practice revisited another elegant application of the sliding window technique. The task was to determine the maximum number of vowels present in any substring of fixed length k. Instead of recalculating the count for every possible substring, the sliding window approach allows the window to move forward while updating the vowel count efficiently. This pattern once again highlights how maintaining a running state can transform a brute-force idea into a clean and optimal solution. 💡 Focus Areas: • Strengthened fixed-size sliding window intuition • Practiced efficient character counting • Improved substring traversal logic • Reinforced constant-time window updates • Focused on writing clean and readable code ⚡ Performance Highlight: Achieved solid runtime efficiency on submission. Each day of deliberate practice adds another layer of clarity to fundamental algorithmic patterns. #LeetCode #60DaysOfCode #100DaysOfCode #DSA #SlidingWindow #Strings #Algorithms #DataStructures #ProblemSolving #CodingJourney #SoftwareEngineering #Programming #Developers #TechCareers

Day 47 on LeetCode — Partition Labels ✂️✅ Today’s problem was a great example of greedy strategy with smart indexing. 🔹 Approach Used in My Solution The goal was to split the string into maximum number of partitions such that each character appears in only one part. Key idea in the solution: • First, store the last occurrence of each character in an array • Traverse the string while maintaining a current partition range • Continuously update the end of the partition using the last index of characters encountered • When the current index reaches end, it means the partition is complete • Store the partition size and start a new one This greedy approach ensures each partition is as small as possible while still valid. ⚡ Complexity: • Time Complexity: O(n) • Space Complexity: O(1) 💡 Key Takeaways: • Learned how preprocessing (last occurrence tracking) simplifies problems • Practiced greedy partitioning techniques • Strengthened understanding of interval expansion logic #LeetCode #DSA #Algorithms #DataStructures #GreedyAlgorithm #Strings #ProblemSolving #Coding #Programming #Cpp #STL #SoftwareEngineering #ComputerScience #CodingPractice #DeveloperLife #TechJourney #CodingDaily #100DaysOfCode #BuildInPublic #AlgorithmPractice #CodingSkills #Developers #TechCommunity #SoftwareDeveloper #EngineeringJourney