How to convert a string to an integer in LeetCode

🧩 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

🎭 Day 279: Faking It (the Smart Way) with mock What if your function depends on an external API, but the API’s down? Or you don’t want to send real network requests while testing? That’s where mock from unittest steps in — it lets you simulate objects or functions. It’s like a stunt double for your code. 🎬 👉 Example: from unittest.mock import MagicMock get_weather = MagicMock(return_value="Sunny ☀️") print(get_weather()) # Output: Sunny ☀️ 💡 Pro tip: Use mocks when testing code that interacts with APIs, files, or databases to isolate logic and prevent real operations. 🔹 Challenge: Mock an API response to test your data parsing logic — no internet required! #Python #Mocking #Testing #DevTips

🚀 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

🧩 Day 54 of my LeetCode Challenge Problem: 3217. Delete Nodes From Linked List Present in Array Difficulty: Medium 🧠 💡 Intuition: We’re given a linked list and an array of integers. Our task is to delete all nodes from the linked list whose values are present in the given array. The trick here is to ensure we do it efficiently since both the array and list can be large. 🧠 Approach: Convert the array nums into a set for O(1) lookups. Use a dummy node to simplify edge cases like deleting the head. Traverse the list using two pointers (prev and cur). If a node’s value exists in the set, skip it. Otherwise, move forward. Finally, return the modified list starting from dummy.next. ⏱ Complexity: Time: O(n + m) Space: O(m) ✅ Example: Input: nums = [1,2,3], head = [1,2,3,4,5] Output: [4,5] Nodes with values 1, 2, and 3 are deleted, leaving the clean list [4,5]. 💬 Takeaway: Efficient lookups with a set and clean traversal logic make linked list problems much easier! #LeetCode #Day54 #LinkedList #Python #CodingChallenge

🚀 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 Challenge – Day 96 Problem: String to Integer (atoi) 🔢➡️💻 This is a classic implementation problem that tests careful handling of edge cases, parsing logic, and boundary conditions. 🧠 Problem Summary: Implement the function myAtoi(string s) that converts a string into a 32-bit signed integer following specific parsing rules. Steps to follow: 1️⃣ Ignore leading whitespaces. 2️⃣ Check the sign (+ or -). 3️⃣ Read digits until a non-digit character is found. 4️⃣ Handle overflow/underflow by clamping the number within the 32-bit signed integer range: Range = [−2³¹, 2³¹ − 1] 5️⃣ Return the final integer. ⚙️ My Approach: Trim leading spaces using lstrip(). Identify the sign based on the first non-space character. Iterate through the string and build the number digit by digit. Multiply by the sign and ensure the result stays within integer limits using max() and min(). 📈 Complexity Analysis: Time: O(n) — traverse each character once. Space: O(1) — only a few variables used. ✨ Key Takeaway: This problem is a great example of careful boundary handling and parsing logic — it’s not just about coding, but about thinking through every possible input case. 🔖 #DSA #100DaysOfCode #LeetCode #ProblemSolving #Python #CodingChallenge #myAtoi #StringParsing #AlgorithmDesign #InterviewPrep #TechCommunity #LearningEveryday

Day 33 / 100 – Maximum Average Subarray (LeetCode #643) Today’s challenge was about finding a contiguous subarray of length k with the maximum average. At first glance, it seems simple, but the key is doing it efficiently. By using a sliding window, I avoided recalculating sums for every subarray, which makes the solution both fast and elegant. This problem reminded me that small optimizations in logic can lead to huge improvements in performance, and thinking carefully about how to structure your solution is just as important as solving the problem itself. 🔍 Key Learnings Sliding window technique updates the sum in constant time for each step. Keeping track of the maximum sum while iterating avoids unnecessary computations. Always ensure floating-point division for correct average calculations. 💭 Thought of the Day Efficiency in coding comes from thinking smart, not from brute force. Sliding window allowed me to write clean and readable solutions while handling all edge cases. Today reinforced that solving problems isn’t just about getting a correct answer — it’s about writing solutions that are elegant, efficient, and scalable. 🔗 Problem Link:https://lnkd.in/gCVb4_pu #100DaysOfCode #Day33 #LeetCode #Python #SlidingWindow #ProblemSolving #Algorithms #DataStructures #CodingChallenge #CodeEveryday #LearningJourney #TechGrowth #Efficiency #CleanCode #PythonProgramming

𝘌𝘷𝘦𝘳 𝘭𝘰𝘰𝘬𝘦𝘥 𝘢𝘵 𝘺𝘰𝘶𝘳 𝘋𝘰𝘤𝘬𝘦𝘳 𝘪𝘮𝘢𝘨𝘦 𝘴𝘪𝘻𝘦 𝘢𝘯𝘥 𝘵𝘩𝘰𝘶𝘨𝘩𝘵… 𝘵𝘩𝘢𝘵 𝘤𝘢𝘯’𝘵 𝘣𝘦 𝘳𝘪𝘨𝘩𝘵? 𝐓𝐡𝐢𝐬 𝐰𝐚𝐬 𝐦𝐞 𝐥𝐚𝐬𝐭 𝐰𝐞𝐞𝐤! Here is the fix: 1. Switched to a lightweight base image Moved from python:3.11 to python:3.9-alpine. Just that change cut the image size by 95%. 2. Optimised layers Grouped related commands to reduce redundant RUN instructions. Fewer layers, faster builds. 3. Added a .dockerignore file Excluded things like virtual environments, cache, and temp files. It made the build context much lighter. 4. Used multi-stage builds First stage for building dependencies. Second stage for production — only what’s needed at runtime. 𝘛𝘩𝘦 𝘳𝘦𝘴𝘶𝘭𝘵𝘴 ? Image size: 47.7 MB (down from 588 MB) Size reduction: −91.89% Faster container startup Reduced deployment time and storage usage Repo in the Comments 👇🏿

🚀 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

🔥 Day 61 of #100DaysOfCode 💡 LeetCode Problem 2125 – Number of Laser Beams in a Bank (Medium) Today’s challenge focused on analyzing a 2D binary matrix representing a bank floor plan equipped with anti-theft laser security devices. Each ‘1’ indicates a device, and each ‘0’ indicates an empty cell. The goal was to determine how many laser beams exist between devices on different rows, ensuring no other row between them contains any active devices. 🧠 Key Idea: Count the number of ‘1’s (active devices) in each row. For every non-empty row, multiply its device count by the previous non-empty row’s count — this gives the number of beams formed between them. ⚙️ Approach: Traverse each row. Count devices ('1') in that row. If the row is not empty, add prev * curr to the result. Update prev as the current count for the next iteration. 💻 Code (Python): class Solution: def numberOfBeams(self, bank: List[str]) -> int: prev, result = 0, 0 for row in bank: curr = row.count('1') if curr: result += prev * curr prev = curr return result 📈 Result: ✅ Runtime: 5 ms — Beats 80.12% ✅ Memory: 19.34 MB — Beats 93.57% 🧩 Concepts Applied: String traversal Matrix interpretation Counting and dynamic accumulation Each day’s challenge continues strengthening my logic-building and Python efficiency. 🚀 #LeetCode #100DaysOfCode #Python #ProblemSolving #CodingJourney #Consistency