Anjali Joshi’s Post

🚀 DSA Progress – Day 109 ✅ Problem #880: Decoded String at Index 🧠 Difficulty: Medium | Topics: String, Math, Simulation, Reverse Traversal 🔍 Approach: Implemented a mathematical reverse-traversal approach to find the K-th character in a decoded string without actually expanding it. Step 1 (Compute Length): Iterate through the encoded string S. If the character is a letter → increment the total size by 1. If it’s a digit d → multiply size by d, since the current decoded string repeats d times. Step 2 (Reverse Simulation): Traverse the string in reverse order to "undo" the decoding. Use K = K % size to keep K within the current string's bounds. If K == 0 and the character is a letter → return that letter (it’s the answer). If the character is a letter → decrement size by 1. If it’s a digit → divide size by that digit to revert the last expansion. This avoids building the huge decoded string and instead works through mathematical reasoning. 🕒 Time Complexity: O(n) — One forward pass to compute size + one backward pass to locate the K-th character. 💾 Space Complexity: O(1) — Uses only a few variables for tracking. 📁 File: https://lnkd.in/gQT35qnU 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem taught me how to simulate decoding in reverse using math and modular reasoning instead of actual string building. It reinforced the power of thinking backwards and optimizing memory for string problems. Handling such problems made me more comfortable with simulation techniques, modulo arithmetic, and efficient string logic. ✅ Day 109 complete — decoded a massive virtual string using pure logic, no brute force! 🧮✨ #LeetCode #DSA #Python #String #Math #Simulation #ReverseTraversal #100DaysOfCode #DailyCoding #InterviewPrep #GitHubJourney

Day 10 of #100DaysOfLeetCode Today’s problem, Count Operations to Obtain Zero, focused on a simple yet powerful iterative process — teaching the importance of loop control, conditional swapping, and mathematical reasoning in problem-solving. 1️⃣ Count Operations to Obtain Zero The challenge was to determine how many operations are needed to make either of two given integers zero. In each operation, the larger number is reduced by subtracting the smaller one, and the process repeats until one of them becomes zero. 🔹 My Approach: Used a while loop to repeatedly subtract the smaller number from the larger one. After every subtraction, incremented a counter to keep track of total operations. Carefully managed the condition to handle both cases where either number could be larger. The process naturally ends when one of the numbers reaches zero. What I Learned: This problem demonstrates how even a simple operation can model deeper mathematical principles, like the Euclidean algorithm for computing GCD. It reinforces that efficiency often lies in understanding the pattern rather than overcomplicating logic. Complexity Analysis: Time Complexity: O(max(num1, num2)) in the naive subtraction form, or O(log n) if optimized using division. Space Complexity: O(1) — constant extra space used. #100days #leetcode #leetcodejourney #100daysofleetcode #consistent #DSA #python

🧩 Day 37 — Pow(x, n) (LeetCode 50) 📝 Problem Implement pow(x, n), which calculates x raised to the power n (i.e., xⁿ). 🔁 Approach -Use Fast Exponentiation (Binary Exponentiation) to compute the result efficiently. -If n is negative, compute the reciprocal: → xⁿ = 1 / (x⁻ⁿ) -When n is even → xⁿ = (x²)^(n/2) -When n is odd → xⁿ = x * xⁿ⁻¹ -This method reduces the number of multiplications drastically. -Implement iteratively for better space efficiency (no recursion stack). 📊 Complexity -Time Complexity : O(log n) -Space Complexity : O(1) 🔑 Concepts Practiced -Exponentiation by squaring -Bit manipulation logic (n //= 2) -Handling negative powers -Mathematical optimization #Leetcode #Python #DSA #Math #Power

🚀 DSA Challenge – Day 97 Problem: Roman to Integer 🔢🏛️ This problem combines string parsing with numerical logic — a classic test of how well you can translate human-readable patterns into computational rules. 🧠 Problem Summary: Given a Roman numeral, convert it into an integer. Roman symbols and their values: Symbol Value I 1 V 5 X 10 L 50 C 100 D 500 M 1000 Special subtraction rules: I before V (5) or X (10) → 4 or 9 X before L (50) or C (100) → 40 or 90 C before D (500) or M (1000) → 400 or 900 ⚙️ My Approach: Maintain a mapping of Roman symbols to integer values. Traverse each symbol and push its value to a stack. If the current value is greater than the previous, subtract the previous from the current before pushing. Finally, sum up all values in the stack. 📈 Complexity Analysis: Time: O(n) — traverse each character once. Space: O(n) — stack stores values temporarily. ✨ Key Takeaway: This problem teaches how to recognize patterns and exceptions while converting symbolic representations into numerical logic — a very common theme in real-world parsing tasks. 🔖 #DSA #100DaysOfCode #LeetCode #RomanToInteger #ProblemSolving #Python #Algorithms #CodingChallenge #TechCommunity #Programming #InterviewPrep #LearningEveryday

🚀 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

💡 Day 17 of 30 – LeetCode Challenge: Word Search (Backtracking) Today’s problem tested my understanding of DFS (Depth-First Search) and Backtracking — a key algorithmic concept used in exploring possible paths or configurations in grids, trees, and graphs. 🧩 Problem Summary We are given an m x n character grid (board) and a string word. We must determine if the word exists in the grid by moving horizontally or vertically through adjacent cells. Each cell can be used only once per word construction. ⚙️ Example Input: board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]] word = "ABCCED" Output: true 📖 Explanation: The path A → B → C → C → E → D forms the word “ABCCED” through valid adjacent cells. 🧠 Approach 1. Traverse every cell in the grid. 2. If the character matches the first letter of word, start a DFS. 3. Explore all 4 directions — up, down, left, right — recursively. 4. Mark cells as visited (temporarily) to prevent reuse. 5. Backtrack after exploring each path (restore cell value). 6. Return True as soon as the word is found. ⏱ Complexity Analysis Time Complexity O(m * n * 4^L) → where L = length of word Space Complexity O(L) (Recursion stack) 🧩 Key Learnings ✨ Learned how DFS + Backtracking can explore all potential paths efficiently. ✨ Importance of restoring state (backtracking) after recursive exploration. ✨ Strengthened my problem-solving in grid-based traversal problems. Backtracking is like exploring a maze — you move forward when possible and step back when you hit a dead end. #Day17 #LeetCode #Backtracking #DFS #WordSearch #CodingChallenge #Python #DSA #WomenWhoCode #ProblemSolving #MTech #LearningJourney

🚀 Day 29 DSA Challenge – Problem 704: Binary Search A timeless classic — the foundation of efficient searching algorithms 🔍 🎯 Problem Statement: Given a sorted array nums and an integer target, find the index of target using an algorithm with O(log n) time complexity. If target doesn’t exist, return -1. 🧩 How I Solved It: Used the Binary Search technique — repeatedly dividing the search space in half. Initialized two pointers, left and right, representing the current search range. Found the middle index mid, compared nums[mid] with target: If equal → returned mid. If smaller → shifted the left boundary rightward. If greater → moved the right boundary leftward. Continued until left > right, meaning the element isn’t found. ⚙️ Performance Stats: ⏱ Runtime: 0ms (⚡ beats 100%) 💾 Memory: 13.48MB (beats 31.70%) ✅ Testcases Passed: 47 / 47 ✨ Insight: Binary Search perfectly demonstrates divide-and-conquer at its best — turning linear scans into logarithmic efficiency 🚀 #LeetCode #Problem704 #BinarySearch #Algorithm #DSA #DivideAndConquer #Python #100DaysOfCode #CodingChallenge

🚀 DSA Challenge – Day 80 Problem: Maximum Distance Between Valid Pairs 🌊📏 Today’s problem tested the combination of binary search and array monotonicity — finding the farthest valid pair between two non-increasing arrays! 🧠 Problem Summary: We’re given two non-increasing arrays, nums1 and nums2. A pair (i, j) is valid if: i ≤ j, and nums1[i] ≤ nums2[j]. The goal is to find the maximum distance (j - i) among all valid pairs. ⚙️ My Approach: 1️⃣ Iterate through each element in nums1. 2️⃣ Use binary search on nums2 to find the farthest valid index satisfying the condition. 3️⃣ Keep track of the maximum j - i distance encountered. This solution leverages the sorted (non-increasing) property of arrays for logarithmic efficiency. 📈 Complexity: Time: O(n log m) → For each element in nums1, a binary search on nums2. Space: O(1) → Only a few variables used. ✨ Key Takeaway: Sometimes, monotonic properties allow you to blend binary search with iteration — turning what looks like a brute-force problem into a clean and efficient search-based solution. ⚡ 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Algorithms #BinarySearch #TwoPointers #CodingChallenge #Python #InterviewPrep #TechCommunity #Optimization #EfficientCode #CodeEveryday

🚀 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