"Day 80: Maximum Distance Between Valid Pairs with Binary Search"

🚀 DSA Challenge – Day 90 Problem: Single Element in a Sorted Array ⚙️🔍 This problem was a clever application of binary search where understanding the index patterns of paired elements was the key to achieving logarithmic efficiency. 🧠 Problem Summary: You are given a sorted array where every element appears exactly twice, except for one element that appears only once. Your task: return that single element in O(log n) time and O(1) space. ⚙️ My Approach: 1️⃣ Used binary search to narrow down the segment containing the single element. 2️⃣ Checked if the middle element breaks the pairing rule — if so, that’s our unique number. 3️⃣ Observed the pattern: Before the single element, pairs start at even indices. After it, pairs start at odd indices. 4️⃣ Used this parity observation to adjust the search boundaries efficiently. 📈 Complexity: Time: O(log n) → Binary search halves the search space each step. Space: O(1) → Constant space used. ✨ Key Takeaway: Sometimes, the structure of sorted pairs reveals more than meets the eye — a small parity trick transforms a linear scan into a logarithmic search. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #BinarySearch #Algorithms #CodingChallenge #Python #Optimization #EfficientCode #TechCommunity #InterviewPrep #LearningByBuilding #CodeEveryday

🚀 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

🚀 DSA Challenge – Day 84 Problem: Reachable Nodes in a Restricted Tree 🌲🚫 This problem was a perfect blend of graph traversal and constraint handling, where we must carefully explore a tree while avoiding restricted nodes. 🧠 Problem Summary: You are given a tree with n nodes (0-indexed) and a list of edges that describe the connections between them. Some nodes are restricted, meaning you cannot visit or pass through them. Starting from node 0, the goal is to determine how many nodes are reachable without visiting any restricted ones. ⚙️ My Approach: 1️⃣ Build an adjacency list representation of the tree. 2️⃣ Store all restricted nodes in a set for quick lookup. 3️⃣ Use Depth-First Search (DFS) to traverse the graph, skipping restricted or already visited nodes. 4️⃣ Accumulate a count of all valid reachable nodes. 📈 Complexity: Time: O(n) → Each node and edge is processed once. Space: O(n) → For adjacency list, recursion stack, and visited set. ✨ Key Takeaway: Even simple DFS problems become interesting when constraints are introduced. Efficient use of sets and recursion can elegantly handle conditions like restricted traversal in trees or graphs. 🌿 🔖 #DSA #100DaysOfCode #LeetCode #GraphTheory #TreeTraversal #DFS #Python #ProblemSolving #CodingChallenge #InterviewPrep #Algorithms #EfficientCode #TechCommunity #CodeEveryday #LearningByBuilding

Day 62: Recover Binary Search Tree (BST) 🌳 I'm continuing my journey on Day 62 of #100DaysOfCode with a challenging BST problem: "Recover Binary Search Tree." The task is to fix a BST where exactly two nodes have been swapped by mistake, all without changing the tree's structure. The key insight relies on the property of Inorder Traversal of a BST, which always yields nodes in ascending order. Inorder Traversal: I first perform a standard inorder traversal (using recursion) to store the node values in an ascending list (inorder). Finding Swapped Nodes: I then iterate through the inorder list to find the two misplaced nodes. A violation occurs when inorder[i-1] > inorder[i]. The first misplaced node (first) is the larger element of the first violation. The second misplaced node (second) is the smaller element of the last violation. Correction: Finally, I swap the values of the two nodes found in the original tree. This method achieves an O(n) time complexity and O(n) space complexity (due to storing the inorder array). My solution was accepted with 100% runtime efficiency! #Python #DSA #Algorithms #BST #InorderTraversal #100DaysOfCode #ProblemSolving

🚀 𝐃𝐚𝐲 𝟏𝟑 𝐨𝐟 #𝟏𝟔𝟎𝐃𝐚𝐲𝐬𝐎𝐟𝐂𝐨𝐝𝐞 — 𝐏𝐚𝐥𝐢𝐧𝐝𝐫𝐨𝐦𝐞 𝐍𝐮𝐦𝐛𝐞𝐫 | 𝐒𝐭𝐫𝐢𝐧𝐠𝐬 🧩 Today’s focus was on a simple yet classic logic check — determining if a number reads the same forward and backward. While it looks straightforward, it’s a great reminder that elegant solutions often come from clarity, not complexity. Problem: 𝐂𝐡𝐞𝐜𝐤 𝐢𝐟 𝐚𝐧 𝐢𝐧𝐭𝐞𝐠𝐞𝐫 𝐢𝐬 𝐚 𝐩𝐚𝐥𝐢𝐧𝐝𝐫𝐨𝐦𝐞. Approach: Convert the integer to a string and compare it with its reverse. Time Complexity: O(n) Space Complexity: O(n) This small exercise reinforces foundational reasoning that scales up when designing more complex systems — where reversing, mirroring, or symmetry detection shows up in data validation, pattern recognition, and even natural language tasks. 🔗 GitHub: https://lnkd.in/gaim_PJS #Python #LeetCode #CodingChallenge #160DaysOfCode #ProblemSolving #DSA #AIEngineerJourney

🚀 DSA Challenge – Day 98 Problem: Count and Say 🔢🗣️ This problem is a fun example of string construction and pattern recognition, where each term of the sequence describes the previous one — a great exercise in iterative logic and encoding patterns. 🧠 Problem Summary: The Count and Say sequence is defined recursively: countAndSay(1) = "1" countAndSay(n) is the run-length encoding of countAndSay(n - 1) For example: 1 11 → one 1 21 → two 1s 1211 → one 2, one 1 111221 → one 1, one 2, two 1s ⚙️ My Approach: 1️⃣ Base cases: return "1" for n=1, "11" for n=2. 2️⃣ Start with "11" and iteratively build the next term by counting consecutive identical digits. 3️⃣ Construct each new term using run-length encoding logic. 4️⃣ Repeat this process until reaching the nth term. 📈 Complexity Analysis: Time: O(n × m) → where m is the average length of intermediate strings. Space: O(m) → for storing the temporary encoded string. ✨ Key Takeaway: This challenge reinforces how string processing and pattern generation can be elegantly solved through careful iteration — a perfect blend of logic and observation. 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #StringManipulation #Python #Algorithms #CodingChallenge #TechCommunity #InterviewPrep #LearningEveryday #CountAndSay

🚀 DSA Challenge – Day 88 Problem: Count Subarrays with Sum Equal to K 📊🔥 This problem was an excellent exercise in using prefix sums and hashmaps to efficiently track cumulative sums and identify subarrays that meet a specific target. 🧠 Problem Summary: Given an array of integers nums and an integer k, find the total number of contiguous subarrays whose sum equals k. ⚙️ My Approach: 1️⃣ Maintain a running prefix sum s as we iterate through the array. 2️⃣ Use a hashmap hashMap to store how many times each prefix sum has appeared. 3️⃣ For each element, check if (s - k) exists in the hashmap — if yes, it means a subarray summing to k ends at the current index. 4️⃣ Update the hashmap with the new prefix sum count. 📈 Complexity: Time: O(n) — each element is processed once. Space: O(n) — for storing prefix sums in the hashmap. ✨ Key Takeaway: Prefix sum combined with a hashmap is a powerful technique to convert subarray problems from O(n²) brute force into elegant O(n) solutions. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #HashMap #PrefixSum #CodingChallenge #Python #Algorithms #EfficientCode #InterviewPrep #TechCommunity #CodeEveryday #LearningByBuilding

🚀 LeetCode #1625: Lexicographically Smallest String After Applying Operations Today’s problem was about transforming a numeric string using two operations: adding a value to digits at odd indices and rotating the string, to get the lexicographically smallest result possible. The challenge was to handle infinite possibilities smartly. I used a Breadth First Search (BFS) approach to systematically explore all reachable string states while keeping track of visited ones. 💡 Key Takeaways: - Some problems don’t need a direct formula, they need systematic exploration. - BFS is not just for graphs; it’s a powerful tool for exploring state transitions too. - Modular arithmetic and rotation logic often come together in string manipulation problems. This one was a great reminder that clean logic and state tracking can solve even the most “infinite looking” problems efficiently. #LeetCode #ProblemSolving #Python #DSA #CodingChallenge #Algorithms #BFS #StringManipulation #LearningEveryday

🚀 Solved LeetCode 3234: Count Substrings with Dominant Ones! 🧠 Just tackled a challenging substring problem: 3234. Count the Number of Substrings With Dominant Ones. The goal is to find all substrings where the count of '1's is greater than or equal to the square of the count of '0's. A simple O(N²) approach is too slow, so a more optimized strategy is needed. My Approach: Key Insight: The condition ones >= zeros² means the number of zeros in any valid substring is small (at most √N). This is the key to optimization. Fix the Endpoint: I iterate through the string, fixing the end of the potential substring. "Zero-Hopping" Technique: From the end, I iterate backward, but instead of going one by one, I "hop" from each '0' to the previous '0'. A precomputed array makes this hop O(1). Efficient Counting: At each hop, I calculate the number of valid start positions in the segment between the two zeros, bringing the total time complexity down to O(N√N). This was a great puzzle in finding the bottleneck and building an algorithm around it! 🔗 Problem Link: https://lnkd.in/gpmZdskg #LeetCode #Coding #Algorithm #Python #ProblemSolving #SoftwareEngineering #Optimization #LeetCode #Coding #Algorithm #Python #Programming #InterviewPrep

⚡ Day 88 of #100DaysOfDSA – Next Permutation 🔁 📌 Problem. no 31: Implement an algorithm to rearrange numbers into the next lexicographically greater permutation of numbers. If no such arrangement exists, transform it into the lowest possible order (i.e., sorted in ascending order). 🚀 Runtime: 0 ms – Beats 💯% of Python submissions 💾 Memory: 12.43 MB – Beats 52.01% of solutions 💻 Language Used: Python ✅ Status: Accepted – All 266 test cases passed successfully! This problem was a great exercise in in-place array manipulation and understanding lexicographical ordering. It strengthened my skills in reverse traversal and efficient element swapping to achieve the next permutation sequence. 🔑 Key Learnings: ✔️ Learned how to find and swap pivot points efficiently ✔️ Improved logic-building for in-place array operations ✔️ Understood how permutations can be generated without extra space 🎯 Day 88 — A solid step forward in mastering array algorithms and improving my analytical approach to sequence transformations! 🔥💡 #100DaysOfCode #100DaysOfDSA #LeetCode #PythonProgramming #DataStructures #AlgorithmPractice #CodeNewbie #DailyCoding #ProblemSolving #TechJourney #WomenWhoCode #CodeLife #CodingChallenge #DSAChallenge #DeveloperLife #PythonDeveloper #LearnToCode #CodingCommunity #CodeEveryday #SoftwareEngineering #KathirCollegeOfEngineering #KathirCollege #BTechLife #AIDS #FutureEngineer #CodingMotivation #ProgrammingSkills