Implementing myAtoi: A String to Integer Problem

🚀 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 Progress – Day 101 ✅ Problem #443: String Compression 🧠 Difficulty: Medium | Topics: Array, String, Two Pointers, In-place Modification 🔍 Approach: Implemented an in-place array compression using two pointers: Step 1 (Traversal): Use a pointer i to traverse the array and a pointer index to write compressed characters. Step 2 (Count Repeats): For each character, count consecutive repeating characters. Step 3 (Write Characters): Write the character at chars[index]. If count > 1, convert it to a string and write each digit at chars[index]. Increment index accordingly. Step 4 (Continue): Repeat until the entire array is processed. Return index as the new length. 🕒 Time: O(n), traverse array once. 💾 Space: O(1), in-place modification, no extra array. 📁 File: https://lnkd.in/gH_3QQgU 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem reinforced the two-pointer technique and in-place array manipulation. It helped me practice handling consecutive elements efficiently and writing counts correctly without extra space. Breaking it into traversal + counting + writing made the solution clean and modular. ✅ Day 101 complete — compressed sequences in arrays like a pro! ✨🔡📏 #LeetCode #DSA #Python #Array #String #TwoPointers #InPlace #DailyCoding #InterviewPrep #GitHubJourney

🚀 DSA Progress – Day 113 ✅ Problem #1910: Remove All Occurrences of a Substring 🧠 Difficulty: Medium | Topics: String, Stack, Simulation 🔍 Approach: Implemented an incremental string-building method to remove occurrences of a given substring efficiently: Step 1 (Iterate & Build): Traverse the input string s character by character and append each character to result. Step 2 (Check for Pattern): After each append, check if the end of result matches the substring part. Step 3 (Remove Pattern): If a match is found at the end → remove that substring immediately. This ensures that removal is done dynamically and newly formed occurrences are also eliminated — similar to how a stack works (push character → pop if matched). 🕒 Time Complexity: O(n × m) — Each append may check the substring of size m. 💾 Space Complexity: O(n) — The result string grows based on remaining characters. 📁 File: https://lnkd.in/gkDDzfJY 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem reinforced incremental string processing and how checking only the suffix avoids repeated full scans. The approach acts like a stack, keeping the logic clean and efficient. Good practice for pattern removal, text filters, and editor-based undo logic. ✅ Day 113 complete — cleaned up messy text like a digital sanitizer 🧽✨ #LeetCode #DSA #Python #Strings #Simulation #StackLogic #DailyCoding #InterviewPrep #GitHubJourney

🚀 Product of Array Except Self — LeetCode #238 Today, I solved one of the most elegant problems in array manipulation — “Product of Array Except Self.” 🧩 Problem in short: Given an integer array nums, return an array answer such that answer[i] equals the product of all numbers in nums except nums[i], ✅ Without using division ✅ In O(n) time ✅ With O(1) extra space 💡 Key Insight — Prefix & Suffix Products Instead of recalculating every product, the trick is to use two passes: First pass: Store the product of all elements before each index (prefix). Second pass: Multiply each element by the product of all elements after it (suffix). This way, each position in the output represents the product of all other elements — efficiently and elegantly. ⚙️ Complexity Time: O(n) Space: O(1) (excluding the result array) 📊 Result ✅ Accepted — Runtime: 20 ms ⚡ Beats 74.21% in performance and 55.22% in memory usage Every problem like this reinforces one key principle: In interviews (and real-world problems), pattern recognition always beats rote memorization. This one beautifully highlights the Prefix–Suffix Pattern, seen in problems like Trapping Rain Water and Subarray Product. #LeetCode #DSA #CodingInterview #Python #Arrays #PrefixSuffix #ProblemSolving

🚀 DSA Progress – Day 110 ✅ Problem #392: Is Subsequence 🧠 Difficulty: Easy | Topics: Two Pointers, String, Greedy 🔍 Approach: Implemented a Two-Pointer approach to determine if one string (s) is a subsequence of another (t). Step 1 (Initialization): Start two pointers — i for string s and j for string t. Step 2 (Traversal): Traverse through both strings: If s[i] == t[j], move both pointers ahead (found a matching character). Otherwise, move only j to continue searching in t. Step 3 (Final Check): If all characters of s are matched (i == len(s)), return True; otherwise, False. This simple yet efficient approach ensures we verify order preservation without needing consecutive matches. 🕒 Time Complexity: O(n) — traverse through string t once. 💾 Space Complexity: O(1) — constant extra space used. 📁 File: https://lnkd.in/gnPitwpj 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem reinforced the two-pointer technique, teaching me how to efficiently track sequences without extra data structures. It also served as a foundational exercise for more complex problems like Longest Common Subsequence and Sequence Matching. A great reminder that elegant solutions often come from simple logic and careful pointer movement. ✅ Day 110 complete — traced hidden letters across timelines to confirm their order! ✨🔤🎯 #LeetCode #DSA #Python #TwoPointers #String #Greedy #Subsequence #100DaysOfCode #DailyCoding #InterviewPrep #GitHubJourney

🧠 Day 28 DSA Challenge – Problem 745: Prefix and Suffix Search This problem was a deep dive into efficient string mapping and prefix-suffix optimization 🔍 🎯 Problem Statement: Design a special dictionary that allows searching words by both a prefix and a suffix. Implement the WordFilter class such that f(pref, suff) returns the largest index of the word matching both conditions — or -1 if none exist. 🧩 How I Solved It: Built a hash map (dictionary) to store all possible prefix-suffix combinations as keys. For each word, I combined every prefix and suffix pair using a unique separator (#) to avoid overlap. Stored the latest index for each combination, ensuring that the lookup returns the largest valid index efficiently. The f() method simply checks for the combined key in the map — making searches O(1) after preprocessing. ⚙️ Performance Stats: ⏱ Runtime: 1152ms (beats 50%) 💾 Memory: 91.98MB (beats 81.25%) ✅ Testcases Passed: 17 / 17 ✨ Insight: This challenge emphasized the power of hash-based precomputation — trading space for blazing-fast lookup performance ⚡ #LeetCode #Problem745 #PrefixSuffixSearch #DSA #HashMap #StringManipulation #CodingChallenge #Python #100DaysOfCode #KeepBuilding

🚀 Day 42 of #100DaysOfCode — Leetcode + HackerRank Edition! Today’s challenge was a deep dive into string-based arithmetic — no shortcuts allowed! 🧩 multiply(num1: str, num2: str) -> str — Multiply two non-negative integers represented as strings, without using int() or BigInteger. 📌 Challenge: → No built-in conversion from string to integer → No BigInteger libraries → Just pure digit-by-digit simulation, like manual multiplication → Example: num1 = "123", num2 = "456" ✅ Output: "56088" 🔍 Approach: → Reversed both strings to simplify digit placement → Used ASCII math: ord(char) - ord('0') to extract digits → Stored intermediate products in an array of size len(num1) + len(num2) → Managed carry manually and built the final string from the result array 💡 What made it click: → Realized that each digit product lands at position i + j in the result array → Practiced dry runs to visualize how "123" * "456" becomes "56088" → Saw how carry propagation works across the array → Appreciated how reversing strings simplifies index math 📚 What I learned: ✅ How to simulate arithmetic without integer conversion ✅ How to use ASCII tricks to decode digits ✅ How to manage carry and build results step-by-step ✅ The power of dry runs to debug and understand logic Have you ever built a calculator or tackled string-based math problems? Let’s swap strategies and visual walkthroughs 💬 #Day42 #Leetcode #Python #StringManipulation #ASCIITricks #LearnInPublic #CodeNewbie #TechJourney #100DaysOfCode #DSA

👇 🚀 LeetCode Problem: String to Integer (atoi) 📘 Problem #8 | Medium Level 🧠 Concept: This problem is all about manually converting a string into an integer, similar to how the C/C++ atoi() function works — but with extra rules for spaces, signs, and number limits. 💡 Key Steps to Solve: Trim spaces – Ignore any leading whitespace. Check the sign – Identify if the number is positive or negative (+ / -). Extract digits – Read characters until a non-digit appears. Handle overflow – Clamp results within 32-bit signed integer range: Minimum: -2³¹ = -2147483648 Maximum: 2³¹ - 1 = 2147483647 Return the result – Considering the sign and bounds. 🧩 Example: Input: " -42" Output: -42 Input: "4193 with words" Output: 4193 Input: "-91283472332" Output: -2147483648 🔥 Takeaway: This challenge strengthens your understanding of: String parsing Edge case handling Integer overflow prevention #LeetCode #Coding #Python #ProblemSolving #Atoi #StringToInteger #DataStructures #Algorithms #100DaysOfCode

🧩 Day 38 / 100 – Transpose Matrix (LeetCode #867) Today’s problem focused on understanding matrix manipulation — specifically, the Transpose of a matrix. Transposing means flipping a matrix over its diagonal, turning rows into columns and columns into rows. It’s a simple concept but helps strengthen 2D array traversal logic — especially how to navigate nested loops cleanly and avoid index confusion. This was a good reminder that clarity and structure matter just as much as complexity. 🔍 Key Learnings Transposing a matrix means swapping element positions — matrix[i][j] → result[j][i]. Use nested loops efficiently to fill the new matrix with swapped indices. Always keep track of dimensions — rows become columns and vice versa. 💭 Thought of the Day Even small transformations like a transpose can teach big lessons in clean logic. Sometimes we overthink “hard” problems, but mastering basics like matrix traversal builds the foundation for solving advanced ones like rotation or dynamic programming grids. 🔗 Problem Link:https://lnkd.in/gHKB9h4b #100DaysOfCode #Day38 #LeetCode #Python #Matrix #Transpose #ProblemSolving #Algorithms #DataStructures #CodingChallenge #CodeEveryday #LearningJourney #CleanCode #TechGrowth #PythonProgramming

🚀 DSA Progress – Day 117 ✅ Problem #946: Validate Stack Sequences 🧠 Difficulty: Medium | Topics: Stack, Simulation, Array 🔍 Approach: Implemented a stack-based simulation to validate push and pop sequences: Step 1 (Initialization): Create an empty stack st and pointers i and j for pushed and popped arrays. Step 2 (Push Elements): Iterate through pushed, pushing each element onto the stack. Step 3 (Pop Check): After each push, check if the top of the stack matches popped[j]. While the stack is not empty and top matches popped[j], pop from the stack and increment j. Step 4 (Final Validation): After processing all elements, if the stack is empty, the sequences are valid; otherwise, they are invalid. This approach simulates the real stack behavior step by step, ensuring that push/pop operations match the given sequences. 🕒 Time: O(n), each element is pushed and popped at most once. 💾 Space: O(n), for the stack. 📁 File: https://lnkd.in/gJJBfAjc 📚 Repo: https://lnkd.in/g8Cn-EwH 💡 Learned: This problem demonstrates how to simulate stack operations efficiently. It reinforced understanding of stack behavior and pointer manipulation. Using a simple stack and two pointers made the solution clean and intuitive. ✅ Day 117 complete — mastered the art of validating stack choreography! 🧩📦✨ #LeetCode #DSA #Python #Stack #Simulation #Array #DailyCoding #InterviewPrep #GitHubJourney