Solved LeetCode Problem #3542 with Python and Stack Data Structure

⏳ Leetcode #1611: Minimum One Bit Operations to Make Integers Zero 🔍 Today I picked up a problem that looked chaotic at first: transforming any integer into zero using very restricted bit-flip rules. Every bit could only flip if the bits below it satisfied certain conditions, making the process feel unpredictable 🧩. But once I dug deeper, something interesting appeared. The pattern wasn’t random at all; it was secretly following Gray Code. That realization turned a confusing sequence of operations into a clean, structured transformation ✨. ✅ Key Insight: The number of operations directly aligns with converting a Gray-Code-like representation of n into its binary form. ✅ Time Complexity: O(log n) ✅ Space Complexity: O(1) These are the moments that make problem solving rewarding: when the “why is this so messy?” suddenly becomes “this is actually lowkey clean” 🧠💡. #DataStructures #LeetCode #CodingChallenge #ProblemSolving #Python #DSA #ComputerScience #learningEveyDay

🚀Day 71 of #100DaysOfCode Today's challenge was LeetCode Problem #3228 - Maximum Number of Operations to Move Ones to the End. This problem focused on binary string manipulation and calculating the maximum possible operations under specific conditions. It tested the ability to analyze how '1's can be shifted past '0's efficiently while maintaining optimal time complexity. Key Learnings: Applied an efficient linear approach to avoid unnecessary simulations. Learned to track and update the count of '1's dynamically during iteration. Strengthened problem-solving strategies for string-based algorithmic questions. Language Used: Python Runtime: 55 ms (Beats 74.85%) Memory: 18.12 MB (Beats 54.49%) Day 70 represents continuous progress in improving logical reasoning and coding efficiency. Each solved problem builds a stronger foundation for advanced algorithmic thinking and real-world software development. #LeetCode #Python #ProblemSolving #CodingChallenge #100DaysOfCode #Algorithm #DataStructures #Mythyly

💻 Day 59 of #100DaysOfCode Solved LeetCode Problem 1716: Calculate Money in Leetcode Bank (Easy) 🏦 This problem involves a weekly incremental saving pattern — each Monday starts with a higher base deposit, and daily savings increase sequentially throughout the week. 🔹 Concepts Applied: Arithmetic Progression (AP) Modular division for week/day tracking Mathematical optimization (O(1) solution) ✅ Runtime: 0 ms — Beats 100% ✅ Memory: 17.94 MB This problem highlights how mathematical patterns can simplify what initially seems iterative into an elegant constant-time formula. #LeetCode #CodingJourney #Python #ProblemSolving #100DaysOfCode #MathematicsInProgramming #CodeOptimization #LearningEveryday

🚀#3217: Delete Nodes from Linked List present in an Array Recently, I explored an interesting problem involving the removal of specific nodes from a linked list based on a given list of values. 💡 Problem Overview: Given a linked list and a list of numbers nums, the task is to delete all nodes whose values are present in nums. 🔍 Approach Summary: 1️⃣ Convert nums into a set for constant time lookups. 2️⃣ Traverse the linked list using two pointers, curr (current node) and prev (previous node). 3️⃣ If the current node’s value is in the set: - If it’s the head, move the head forward. - Otherwise, link the previous node to the next node, effectively removing the current one. 4️⃣ Continue traversing until all matching nodes are removed. ✨ Key Learnings: - Utilizing a set improves efficiency for value lookups. - Careful handling of the head node prevents pointer issues. - Clean traversal logic leads to better readability and fewer edge case errors. #Python #DataStructures #LinkedList #Coding #ProblemSolving #LeetCode #DSA #LearningJourney

This simple #Claude Code hack has reduced token usage by ~90%. It adopts the "Code Execution with MCP" concept published by Anthropic. Remove preloaded MCP tools from context and use Python to execute tools via bash instead. BTW, this can be optimized much further. Insane!

🚀 Day 21 of 30 LeetCode Challenge – Binary Tree Right Side View 🌳➡️ Today’s challenge was to extract the right-side view of a binary tree — the set of nodes visible when looking at the tree from the right. 🔍 Core Idea We perform a level-order traversal (BFS) and capture the last node of every level, because that’s what appears from the right side. This approach ensures we don’t miss any node that contributes to the right profile of the tree. ✨ What I Learned BFS is extremely useful for level-wise operations. Capturing the rightmost node at each level efficiently gives the answer. Many real-world problems rely on similar views/perspectives in tree structures. 📌 Output Example Input: [1,2,3,null,5,null,4] Right view: [1,3,4] #Day21 #LeetCode #DSA #Python #TwoPointers #CodingChallenge #DynamicProgramming #WomenWhoCode #MTech #ProblemSolving

𝗗𝗮𝘆 𝟯𝟵 𝗼𝗳 #𝟭𝟴𝟬𝗗𝗮𝘆𝘀𝗢𝗳𝗖𝗼𝗱𝗲 Today, I built on the first/last occurrence solution to 𝗰𝗼𝘂𝗻𝘁 𝗼𝗰𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝗲𝘀 𝗼𝗳 𝗮 𝘁𝗮𝗿𝗴𝗲𝘁 𝗶𝗻 𝗮 𝘀𝗼𝗿𝘁𝗲𝗱 𝗮𝗿𝗿𝗮𝘆 𝘄𝗶𝘁𝗵 𝗱𝘂𝗽𝗹𝗶𝗰𝗮𝘁𝗲𝘀. Using the same lower_bound and upper_bound helpers: Lower bound → first index where element ≥ target Upper bound → first index where element > target The count is simply: count = upper_bound - lower_bound This gives an O(log n) solution — much faster than scanning the entire array, especially with many duplicates. It’s a great example of how breaking a problem into reusable pieces leads to clean and efficient code. Perfect for analytics, frequency analysis, and search optimizations! 📊 #Python #Algorithms #BinarySearch #FrequencyCount #Coding #ProblemSolving

⚡ Day 92 of #100DaysOfDSA – Single Number III 🔍 📌 Problem. no 260: Given an array where every element appears twice except for two unique numbers, find both unique elements that appear only once. 🚀 Runtime: 0 ms – Beats ⚡100.00% of Python submissions 💾 Memory: 13.23 MB – Beats 65.94% 💻 Language: Python ✅ Result: Accepted – 35 / 35 test cases passed flawlessly This problem pushed me to dive deeper into bit manipulation and understand how XOR can efficiently isolate unique numbers without using extra space. 🔑 Key Learnings ✔️ XOR helps cancel out repeating elements effectively ✔️ Smart bit-level logic simplifies complex comparisons ✔️ Achieved O(n) time and O(1) space – clean and optimal 🎯 Day 92 — Every bit counts when it comes to optimization! ⚙️🔥 #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

Day 31 / 100 – Add Strings (LeetCode #415) Today’s challenge was all about simulating manual addition without using any built-in integer conversions. Given two numbers as strings, the task was to return their sum — also as a string. This problem really emphasized the importance of breaking problems into small, logical steps rather than relying on shortcuts. 🔍 Key Learnings Recreated the digit-by-digit addition process using ASCII values. Practiced handling carry-over efficiently while iterating backward. Strengthened my understanding of string manipulation and arithmetic logic. 💭 Thought of the Day True problem-solving isn’t about using built-ins — it’s about understanding how things work underneath. Today reminded me that mastery grows when we rebuild the basics from scratch, not when we avoid them. 🔗 Problem Link: https://lnkd.in/gHMt9vj9 #100DaysOfCode #Day31 #LeetCode #Python #ProblemSolving #StringManipulation #Algorithms #DataStructures #CodingChallenge #CodeEveryday #TechGrowth #LearningJourney

🔁 Day 45 of #100DaysOfDSA — Reverse Linked List Problem: Reverse Linked List (LeetCode #206) Given the head of a singly linked list, reverse it and return the reversed list. Concepts Used: 🧠 Stack-based approach Traverse the linked list and push each node’s value into a stack. Then reassign values by popping from the stack to reverse the list. 🧩 Learning Reflection: This problem helped me understand how stacks can simplify linked list manipulations. Though not the most space-efficient solution, it reinforces the concept of LIFO (Last In, First Out) operations beautifully. ⏱️ Complexity: Time: O(N) Space: O(N) 💬 Closing Thought: Sometimes, using an extra data structure makes logic clearer — and that’s okay while learning. #LeetCode #DSA #LinkedList #Python #100DaysOfCode #CodingJourney