How to Convert Roman Numerals to Integers in Python

🚀 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

💼 LeetCode Daily Challenge: 3354. Make Array Elements Equal to Zero Today I worked on an interesting simulation based problem that combines logical movement with mathematical reasoning. 🔍 Problem Overview: - You are given an integer array containing non-negative elements. - The task is to determine the number of valid starting positions (and directions) such that all elements become zero after performing a series of operations. - The movement involves direction reversals and decrements, making direct simulation tricky. 💡 Key Observations: - Instead of brute force simulation, prefix sum analysis helps determine valid balance points. - Each zero acts as a potential pivot; by analyzing prefix and total sums, we can efficiently identify valid selections. - The solution leverages mathematical balance conditions to avoid unnecessary computation. 📊 Complexity: Time Complexity: O(n) Space Complexity: O(1) 🎯 Takeaways: - Simulation problems often hide elegant mathematical patterns. - Prefix sums are powerful tools for deriving insights without explicit iteration over all possibilities. #LeetCode #ProblemSolving #Python #DSA #Algorithm #CodingChallenge #PrefixSum #DataStructures #LearningEveryday #Efficiency

🚀 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 36 of 100 — Count Operations to Obtain Zero (#LeetCode 2169) Today’s problem was a simple yet oddly satisfying one it felt like a math puzzle disguised as a loop. It reminded me how sometimes, even the easiest problems can hold a small “aha!” moment when you spot the pattern. 🧠 What I figured out The problem is basically a modified version of the Euclidean algorithm for finding the GCD. Instead of just returning the GCD, you count how many subtraction (or division) steps it takes until one number becomes zero. Using division instead of repeated subtraction makes the solution much more efficient. 💻 My thought process I first thought of literally subtracting the smaller number from the larger one repeatedly but that was painfully slow. Then I realized I could just count how many times it fits using integer division, and the logic becomes clean and fast. 📊 Complexity: Time — O(log(min(num1, num2))) Space — O(1) 💬 Reflection This problem reminded me that optimization isn’t always about big algorithms sometimes it’s just about seeing the pattern. It’s funny how often elegant solutions hide behind simple loops. #100DaysOfLeetCode #Day36 #LeetCodeJourney #ProblemSolving #Python #DSA

⚡ 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

🚀 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 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 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