"LeetCode Challenge: Lexicographically Smallest String"

🚀 Day 40 / 100 — #100DaysOfLeetCode 💡 (1625) Lexicographically Smallest String After Applying Operations (Medium) This was a really fun graph + BFS problem disguised as a string manipulation challenge. The trick is realizing that applying the two operations (add & rotate) repeatedly explores a finite set of states, forming an implicit graph, where each node is a string transformation. 🧩 Problem Overview You are given: A numeric string s Two integers a and b You can repeatedly: Add a (mod 10) to all digits at odd indices. Rotate the string right by b positions. Find the lexicographically smallest string possible after any number of operations. ⚙️ Approach — BFS on States Used Breadth-First Search (BFS) to explore all reachable strings: Start from the initial string s. Use a set vis to track visited states. For each string, generate: One by performing addition on odd indices. One by rotating by b. Continue until all unique transformations are explored. Track the smallest lexicographical string seen. 📈 Complexities Time Complexity: O(10 * n) Each state can appear up to 10 times due to modulo operations, and each state has n length. Space Complexity: O(10 * n) For storing visited transformations. ✅ Key Insights The problem is finite because both operations are modular and cyclic. BFS guarantees we explore all possible reachable strings in an optimal manner. Lexicographical comparison after BFS is straightforward — track the smallest string so far. ✨ Takeaway This problem beautifully demonstrates how: “Even string problems can secretly be graph traversal problems.” It’s a neat mix of modular arithmetic, rotation logic, and state-space search. #LeetCode #100DaysOfCode #BFS #GraphTraversal #StringManipulation #ProblemSolving #Python #Algorithms

🎨 Solving “Sort Colors” — The Dutch National Flag Problem Today I tackled a classic array problem on LeetCode: Sort Colors (#75). 🧩 The Challenge: We are given an array of integers 0, 1, and 2, representing colors: red, white, and blue. The goal is to sort the array in-place so that all 0s come first, followed by 1s, and then 2s — without using built-in sort functions. 💡 Key Insight / Pattern This problem is famously known as the Dutch National Flag problem. The idea is to use three pointers to divide the array into three sections: low → next position for 0 mid → current element under consideration high → next position for 2 We traverse the array once, swapping elements into the correct section. This results in O(n) time and O(1) space — very efficient! 🔹 Approach If nums[mid] == 0: swap with nums[low] → move low and mid forward If nums[mid] == 1: do nothing → move mid forward If nums[mid] == 2: swap with nums[high] → move high backward This single-pass, in-place approach neatly separates the colors while keeping the code simple. 🧠 Pattern Recognized Three-pointer array partitioning — useful for problems involving limited value sets or segregating arrays efficiently. Related Problems: Move Zeroes (#283) Partition Array (#215) Merge Sorted Array (#88) 💬 Takeaway: Understanding patterns like the Dutch National Flag not only helps in solving specific problems efficiently but also trains your mind to see structure in seemingly random arrays — a skill that’s invaluable for coding interviews and problem-solving in general. #LeetCode #DSA #Python #Algorithms #CodingInterview #ProblemSolving #Arrays #TwoPointers #TechJourney

Day 57: Binary Tree Zigzag Level Order Traversal 🎢 I'm continuing my journey with an advanced tree traversal problem on Day 57 of #100DaysOfCode: "Binary Tree Zigzag Level Order Traversal." The challenge is to return the nodes of a binary tree level by level, alternating the direction of traversal (left-to-right, then right-to-left, and so on). My solution builds upon the standard Breadth-First Search (BFS) algorithm, using a queue (deque): Level Traversal: I process the tree level by level, finding the level_size in each iteration. Direction Toggle: I use a boolean flag (left_to_right) to track the current direction. Zigzag Logic: Inside the level loop, I use a simple conditional: if left_to_right is true, I append the node value normally. If it's false, I insert the node value at the beginning of the current level's list (current_level.insert(0, node.val)). Optimal Flip: After processing the entire level, I flip the left_to_right flag (left_to_right = not left_to_right) for the next level. This single-pass BFS approach ensures all nodes are visited exactly once, achieving an optimal O(n) time complexity and O(n) space complexity. My solution was accepted with 100% runtime efficiency! #Python #DSA #Algorithms #Trees #BFS #100DaysOfCode #ProblemSolving #Zigzag

🧩 Day 30 — 4Sum (LeetCode 18) 📝 Problem -Given an integer array nums, return all unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that: -a, b, c, and d are distinct indices -nums[a] + nums[b] + nums[c] + nums[d] == target -Return the answer in any order. 🔁 Approach -Sort the array to handle duplicates efficiently. -Use a recursive k-sum approach that generalizes 2-sum, 3-sum, and 4-sum problems. -For k > 2, recursively reduce the problem: -Fix one number and call kSum for k - 1 on the remaining array. -Skip duplicates to avoid repeating quadruplets. -For k = 2, use the two-pointer technique: -Move pointers inward based on the sum comparison with the target. -Add valid pairs to the result and skip duplicates. -Backtrack after each recursive call to explore all possible combinations. 📊 Complexity -Time Complexity : O(n³) -Space Complexity : O(k) 🔑 Concepts Practiced -Recursive K-Sum pattern -Two-pointer technique -Sorting and duplicate handling -Backtracking with controlled search space #python #DSA #4Sum #ProblemSolving #Leetcode

🧩 Day 29 — 3Sum Closest (LeetCode 16) 📝 Problem Given an integer array nums of length n and an integer target, find three integers in nums such that the sum is closest to target. Return the sum of the three integers. You may assume that each input would have exactly one solution. 🔁 Approach -Sort the array to use the two-pointer technique effectively. -Iterate through each element nums[i] (except the last two) and treat it as the first element of the triplet. -For each i, set two pointers: -left = i + 1 -right = len(nums) - 1 -Compute the sum of the three numbers: -total = nums[i] + nums[left] + nums[right] -If total == target, return total immediately (perfect match). -Otherwise, compare the absolute difference between total and target to update the closestSum. -Adjust pointers: -If total < target, move left pointer right to increase sum. -If total > target, move right pointer left to decrease sum. -Continue until all triplets are checked. -Return the final closestSum. 📊 Complexity -Time Complexity: O(n²)  -Space Complexity: O(1) 🔑 Concepts Practiced -Sorting and two-pointer pattern -Optimization using sorted array and pointer movement -Handling duplicates efficiently -Absolute difference comparison for closest value #Leetcode #python #DSA #Sorting #problemSolving

🚀 LeetCode #1611 – Minimum One Bit Operations to Make Integers Zero Today, I tackled one of the more fascinating bit-manipulation problems on LeetCode — "Minimum One Bit Operations to Make Integers Zero". 🧩 Problem Overview Given an integer n, you must transform it into 0 using two operations: Flip the rightmost (0th) bit. Flip the ith bit if the (i−1)th bit is 1 and all lower bits are 0. The goal is to find the minimum number of operations required. The challenge is to transform an integer n into 0 using specific bit operations that flip bits based on certain constraints. At first glance, it seems like a complex recursive search problem, but the key insight lies in recognizing the pattern of Gray codes. 🔍 Key Insight: The problem follows the structure of reflected Gray code transformations. By analyzing how bits flip in the Gray code sequence, we can derive a recursive relationship that efficiently computes the minimum operations. 💡 Recursive Relation: If f(n) is the minimum number of operations for integer n: f(0) = 0 f(n) = (1 << (k + 1)) - 1 - f(n ^ (1 << k)) where k is the position of the most significant bit (MSB) in n. 🧠 Example Walkthrough n = 3 → binary 11 → result = 2 n = 6 → binary 110 → result = 4 ⚙️ Complexity Time: O(log n) Space: O(log n) (due to recursion depth) 🧩 Takeaway This problem was a great reminder that: Many bit-manipulation problems have elegant recursive or mathematical patterns hidden beneath them. Recognizing symmetry and recursion in binary transformations often leads to O(log n) solutions. #LeetCode #Python #BitManipulation #GrayCode #Algorithms #DataScience

🚀 DSA Challenge – Day 89 Problem: Subsets II (Handling Duplicates in Power Set) ⚙️✨ This problem was a great exploration of recursion, backtracking, and how to systematically avoid duplicate subsets using careful pruning. 🧠 Problem Summary: You are given an integer array nums that may contain duplicates. Your goal: return all possible subsets (the power set) without including any duplicate subsets. ⚙️ My Approach: 1️⃣ First, sort the array — this step helps group duplicates together, which is crucial for skipping them efficiently. 2️⃣ Use recursive backtracking to explore all possible inclusion/exclusion combinations. 3️⃣ Whenever a duplicate element is found (i.e., nums[i] == nums[i-1]), skip it if it’s at the same recursion depth — ensuring unique subset generation. 4️⃣ Keep track of the current subset and add a copy to the result whenever we reach a new state. 📈 Complexity: Time: O(2ⁿ) → Each element can be either included or excluded. Space: O(n) → For recursion and temporary subset storage. ✨ Key Takeaway: Sorting before recursion is often the simplest way to handle duplicates in backtracking problems. With one small condition check, you can turn exponential chaos into structured exploration. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Recursion #Backtracking #Algorithms #CodingChallenge #Python #TechCommunity #InterviewPrep #EfficientCode #LearningByBuilding #CodeEveryday

🚀 DSA Challenge – Day 83 Problem: Minimum Possible Length of Original String from Concatenated Anagrams 🔡✨ This was an elegant string manipulation and frequency-matching problem — a beautiful blend of observation and brute-force validation. 🧠 Problem Summary: You are given a string s, known to be a concatenation of anagrams of some original string t. The task is to determine the minimum possible length of t. ✅ Each substring of length len(t) should contain exactly the same frequency of characters. ✅ The string s can thus be divided into equal-length chunks, all being anagrams of t. ✅ The goal is to find the smallest such length that satisfies this property. ⚙️ My Approach: 1️⃣ Iterate through all divisors i of n = len(s) — potential lengths of t. 2️⃣ For each possible i, check if the string can be divided into equal parts where each part has identical character frequencies. 3️⃣ Use hash maps to store frequency counts and compare each block. 4️⃣ Return the smallest i that satisfies the condition. 📈 Complexity: Time: O(n²) → Checking frequency for each valid divisor. Space: O(k) → For storing character counts per block. ✨ Key Takeaway: When tackling anagram-based problems, frequency comparison is your strongest ally. Instead of guessing patterns, rely on structure and repetition to reveal the hidden base string. 🔍 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #StringManipulation #Anagram #Python #CodingChallenge #InterviewPrep #EfficientCode #HashMap #DataStructures #TechCommunity #CodeEveryday #LearningByBuilding

🚀 Solving Binary Subarray With Sum — From Brute Force to Optimal I recently solved LeetCode 930: Binary Subarray With Sum, and it turned out to be a great learning path across multiple techniques 💡 Problem: Count subarrays in a binary array whose sum equals a target (goal). My approach evolution: 1️⃣ Brute Force (O(n²)) – Check all (i, j) pairs. 2️⃣ Prefix Sum Array – Simplified sum calculation but still O(n²). 3️⃣ Prefix Sum + HashMap (O(n)) – Store prefix frequencies to count valid subarrays efficiently. 4️⃣ Sliding Window – For binary arrays, maintain subarray sum dynamically. 5️⃣ Special Case (goal == 0) – Count zero stretches combinatorially: k * (k + 1) / 2. ✅ Final solution combines: Prefix Sum Frequency (for goal > 0) Zero Stretch Counting (for goal = 0) Key takeaway: From brute force to optimized O(n), this problem teaches how prefix sums, hash maps, and combinatorics work together for elegant problem-solving. #LeetCode #ProblemSolving #DataStructures #Algorithms #CodingJourney #PrefixSum #SlidingWindow #Python

🚀 DSA Challenge – Day 85 Problem: Check if All Integers in a Range Are Covered ✅📏 This problem was an elegant use of the Prefix Sum technique, where I used range updates to efficiently check coverage over an interval. 🧠 Problem Summary: You are given several inclusive integer intervals and a target range [left, right]. You must verify if every integer within [left, right] is covered by at least one of the given intervals. ⚙️ My Approach: 1️⃣ Initialize an array line to track coverage at each integer position. 2️⃣ For every range [a, b], increment line[a] and decrement line[b + 1] — this marks the start and end of coverage. 3️⃣ Convert line into a prefix sum array, so each position reflects how many intervals cover that number. 4️⃣ Finally, iterate through [left, right] to ensure each integer has coverage (> 0). 📈 Complexity: Time: O(n + 52) → Linear scan and prefix sum computation. Space: O(52) → Fixed-size array since ranges are small. ✨ Key Takeaway: Prefix sum is not just for subarray sums — it’s a powerful trick for range marking and coverage problems, offering O(1) updates and O(n) verification. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #PrefixSum #RangeUpdate #ProblemSolving #Algorithms #CodingChallenge #Python #EfficientCode #Optimization #TechCommunity #InterviewPrep #CodeEveryday #LearningByBuilding