Optimizing Perpetual Motion with Modular Arithmetic and Geometry

🚀 Day 57/100 — Navigating Infinite Planes with Obstacles! Today’s Problem: 874. Walking Robot Simulation 🔹 The Goal: Today was about simulating a robot navigating an infinite XY-plane. Given a series of commands to turn or move forward, the robot must avoid specific obstacle coordinates. The objective: find the maximum squared Euclidean distance the robot reaches during its entire journey. 🔹 The Insight: This problem is a masterclass in Search Space Optimization. While a naive approach might check every step against an array of obstacles—leading to O(K \cdot O) complexity—the real way to win is using a HashSet. By hashing obstacle coordinates into strings like "x,y", we turn an expensive search into a lightning-fast O(1) lookup. 🔹 The Logic: Modular Vector Rotation: I used a 4-direction array and the modulo operator to handle 90-degree turns seamlessly without complex if-else chains. Incremental Verification: Instead of "jumping" to the final position, the robot moves one unit at a time. This ensures we detect an obstacle the very moment the robot hits it. Global Peak Tracking: Monitored the squared distance (x^2 + y^2) at every single valid step to ensure the absolute maximum displacement was recorded. ✨ Achievement: Day 57! Moving past the halfway mark by tackling high-performance simulations. It’s a great reminder that even simple movements require rigorous logic and optimized data structures to scale effectively. 🔍 Steps followed: ✔ Set-Based Lookups: Converted the obstacle grid into a HashSet for constant-time collision detection. ✔ Directional Mapping: Managed 2D movement using index-based vector arrays. ✔ Precision Simulation: Implemented step-by-step movement to respect boundary constraints. 🔧 The Stats: Time Complexity: O(N + K) (where N is commands and K is total steps) Space Complexity: O(O) (to store O obstacles) 57 days down, 43 to go. The logic is getting sharper every single day. Let's keep the momentum! 🛠️ #Java #DSA #LeetCode #CodingJourney #100DaysOfCode #SoftwareEngineer #InternshipBound #Programming #Simulation #GraphTheory #Algorithms #Optimization #Day57

🔥 Day 549 of #750DaysOfCode 🔥 🚀 Solved: Robot Collisions (Hard) Today’s problem was a really interesting mix of sorting + stack + simulation — exactly the kind of question that tests real problem-solving skills 💡 🧠 Problem Insight We are given robots with: Positions 📍 Health ❤️ Directions (L / R) When two robots collide: The one with lower health ❌ gets destroyed The stronger one loses 1 health and continues If equal → both destroyed ⚡ Key Idea 👉 Collisions only happen when: A robot moving Right (R) meets one moving Left (L) So the approach becomes: Sort robots by position Use a stack to track right-moving robots Simulate collisions when a left-moving robot appears 🛠️ Approach ✔ Sort indices based on positions ✔ Use stack for R robots ✔ Resolve collisions with L robots ✔ Track alive robots and update health dynamically ⏱️ Complexity Time: O(n log n) (sorting) Space: O(n) 🎯 Key Learnings ✅ Stack is powerful for collision-type problems ✅ Sorting helps simulate real-world order ✅ Only R vs L interactions matter ✅ Clean handling of edge cases is crucial This problem really improved my understanding of simulation problems in DSA 💪 On to Day 550 🚀 #LeetCode #DSA #Java #CodingJourney #ProblemSolving #SoftwareEngineering #Stack #Algorithms #750DaysOfCode

🚀 Day 37 of 100 Days LeetCode Challenge Problem: Walking Robot Simulation Day 37 builds on previous robot problems with a full simulation + direction handling + hashing challenge 🔥 💡 Key Insight: We simulate movement step-by-step, but: 👉 Need to handle: Direction changes Obstacles Track maximum distance 🔍 Core Approach: 1️⃣ Track Direction Use directions array: North → (0,1) East → (1,0) South → (0,-1) West → (-1,0) 👉 Rotate index: Left → (dir + 3) % 4 Right → (dir + 1) % 4 2️⃣ Store Obstacles Efficiently Use a HashSet for O(1) lookup 3️⃣ Simulate Movement For each step: Move 1 unit at a time If next cell is obstacle → stop movement 4️⃣ Track Maximum Distance At every step: Compute x² + y² Keep max value 🔥 What I Learned Today: Simulation problems require step-by-step precision Hashing is essential for fast obstacle checks Direction handling patterns are reusable 📈 Challenge Progress: Day 37/100 ✅ Consistency unstoppable! LeetCode, Simulation, Hashing, Matrix, Direction Handling, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Simulation #Hashing #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

🚀 Day 4 of Problem Solving Journey Today, I tackled LeetCode 3661 – Maximum Walls Destroyed by Robots 🤖💥 🔍 Problem Summary: Given positions of robots and walls on a straight line, each robot can shoot once either left or right within a limited distance. The challenge is to calculate the maximum number of unique walls that can be destroyed without bullets passing through other robots. 🧠 Key Learnings: Sorting helps simplify positional problems Binary search can optimize finding valid ranges Careful handling of edge cases (like robots blocking bullets) Efficient mapping of robot positions to distances ⚡ Approach: Used sorting + binary search to determine reachable walls for each robot and ensured no overlap or blockage affects the final count. ✅ Result: Accepted ✔️ 📌 Consistency is the key — one problem a day keeps improving problem-solving skills! #Day4 #LeetCode #ProblemSolving #Java #CodingJourney #DataStructures #Algorithms #Consistency

🚀 Day 38 of 100 Days LeetCode Challenge Problem: Walking Robot Simulation II Day 38 upgrades the previous problem into a design + simulation + cycle optimization challenge 🔥 💡 Key Insight: The robot moves along the boundary of the grid in a cycle. 👉 Instead of simulating every step: Compute the perimeter cycle length Use modulo to optimize large movements 📌 Cycle length: 2 * (width + height) - 4 🔍 Core Approach: 1️⃣ Understand Movement Pattern Robot moves along edges: East → North → West → South (counterclockwise turns) 2️⃣ Optimize Steps Reduce steps: num = num % cycle_length 👉 Avoid unnecessary full loops 3️⃣ Simulate Remaining Steps Move step-by-step only for reduced num Handle boundary → turn 90° counterclockwise 4️⃣ Track State Maintain: Current position (x, y) Current direction 🔥 What Makes It Interesting: Large inputs → require cycle detection Not just simulation → needs optimization 🔥 What I Learned Today: Repeating patterns → think cycles + modulo Design problems require state management Optimization is key for large constraints 📈 Challenge Progress: Day 38/100 ✅ Still going strong! LeetCode, Simulation, Design Problem, Cyclic Movement, Modular Arithmetic, Arrays, DSA Practice, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Simulation #DesignProblem #ModularArithmetic #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

𝐃𝐚𝐲 𝟕𝟑/𝟑𝟔𝟓 🚀 📌 𝐋𝐞𝐞𝐭𝐂𝐨𝐝𝐞 𝐏𝐎𝐓𝐃: 𝐑𝐨𝐛𝐨𝐭 𝐂𝐨𝐥𝐥𝐢𝐬𝐢𝐨𝐧𝐬 Continuing my 𝟑𝟔𝟓 𝐃𝐚𝐲𝐬 𝐨𝐟 𝐂𝐨𝐝𝐞 journey with a focus on 𝐩𝐫𝐨𝐛𝐥𝐞𝐦-𝐬𝐨𝐥𝐯𝐢𝐧𝐠, 𝐃𝐒𝐀, 𝐚𝐧𝐝 𝐜𝐨𝐧𝐬𝐢𝐬𝐭𝐞𝐧𝐜𝐲. 💪 🔎 𝐀𝐩𝐩𝐫𝐨𝐚𝐜𝐡: Sort robots based on positions. Use a stack to track right-moving robots. When a left-moving robot appears, simulate collisions with stack elements. Resolve collisions based on health values and update survivors accordingly. 🔍 𝐀𝐥𝐠𝐨𝐫𝐢𝐭𝐡𝐦 𝐮𝐬𝐞𝐝: Sorting + Stack-based simulation. ⏱ 𝐓𝐢𝐦𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧 log 𝐧) 🧠 𝐒𝐩𝐚𝐜𝐞 𝐂𝐨𝐦𝐩𝐥𝐞𝐱𝐢𝐭𝐲: 𝐎(𝐧) 📈 𝐊𝐞𝐲 𝐭𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Collision problems can often be modelled using stacks to simulate interactions in order. #LeetCode #LeetCodeDaily #365DaysOfCode #DSA #Java #Stack #Simulation #ProblemSolving #LearningInPublic 👨💻 🔗 Problem link in comments 👇

🚀 Day 36 of 100 Days LeetCode Challenge Problem: Robot Return to Origin Day 36 is a simple but important simulation + counting problem 🔥 💡 Key Insight: To return to origin (0,0): Total moves Right = Left Total moves Up = Down 👉 If both conditions satisfy → ✅ robot returns to origin 🔍 Core Approach: 1️⃣ Initialize Counters x = 0, y = 0 2️⃣ Process Each Move 'R' → x++ 'L' → x-- 'U' → y++ 'D' → y-- 3️⃣ Final Check If (x == 0 && y == 0) → true Else → false 💡 Alternative Approach: Count occurrences: count('R') == count('L') count('U') == count('D') 🔥 What I Learned Today: Simple problems test basic logic clarity Simulation problems are about correct tracking Don’t overcomplicate—keep it clean 📈 Challenge Progress: Day 36/100 ✅ Consistency still going strong! LeetCode, Simulation, Strings, Counting, Coordinates, Arrays, DSA Practice, Coding Challenge, Problem Solving #100DaysOfCode #LeetCode #DSA #CodingChallenge #Simulation #Strings #ProblemSolving #TechJourney #ProgrammerLife #SoftwareDeveloper #CodingLife #LearnToCode #Developers #Consistency #GrowthMindset #InterviewPrep

#Day30 of DSA Journey | LeetCode 874 - Walking Robot Simulation Today’s problem was all about simulation + direction handling + hashing — a very practical and fun one! Problem Summary: A robot starts at (0,0) facing North and follows a sequence of commands: -2 → Turn Left -1 → Turn Right 1 to 9 → Move forward step-by-step There are obstacles on the grid, and the robot must stop if it encounters one. Goal: Find the maximum squared distance from the origin reached at any point. Key Learnings: Use direction vectors to simplify movement North → (0,1) East → (1,0) South → (0,-1) West → (-1,0) Store obstacles in a HashSet for O(1) lookup Convert (x, y) → string "x,y" or use a pair hash Move step-by-step (not directly k steps!) to handle obstacles correctly Track max distance using: maxDist = max(maxDist, x*x + y*y) Approach: Initialize direction = North Process each command Rotate left/right using modular arithmetic Move step-by-step and stop if obstacle found Update max distance at each step Time Complexity: O(N * K) → N commands, each moving up to K steps Space Complexity: O(M) → for storing obstacles Takeaway: This problem strengthens your understanding of: Simulation problems Direction handling Efficient lookup using hashing #DSA #LeetCode #CodingJourney #JavaScript #ProblemSolving #100DaysOfCode

#day63 🚀 19/04/26 — Precision Tracking: Robot Return to Origin Today, I solved Robot Return to Origin (LeetCode 657), applying coordinate-based tracking to determine if a sequence of moves returns a robot to its starting position. This problem is a great exercise in Simulation and state management using simple array counters. 🤖 The Origin Logic The objective is to determine if a robot, starting at (0,0) on a 2D plane, returns to (0,0) after executing a string of moves: 'U' (up), 'D' (down), 'L' (left), and 'R' (right). The Logic: Coordinate Simulation State Representation: I used a small integer array arr of size 2 to represent the (x, y) coordinates, initialized at {0, 0}. arr[0] tracks horizontal movement (x-axis). arr[1] tracks vertical movement (y-axis). Linear Execution: I iterated through the moves string exactly once. Vertical: Increment arr[1] for 'U' and decrement for 'D'. Horizontal: Increment arr[0] for 'R' and decrement for 'L'. Verification: The robot returns to the origin if and only if both final coordinates are zero (arr[0] == 0 && arr[1] == 0). Complexity: Time: O(n) where n is the length of the moves string. Space: O(1) as we only use a fixed-size array regardless of the number of moves. 📈 Consistency Report: Foundations of Simulation Today's solution emphasizes that complex tracking problems can often be reduced to basic arithmetic operations on a fixed state. This is a more streamlined version of the Two-Pointer and Sliding Window techniques I've been mastering—while those patterns focus on sub-segments of data, this simulation tracks the global state of an object over time. Huge thanks to the roadmap for building this momentum! Moving from array partitioning to 2D state simulation shows how my problem-solving intuition is expanding. My O(n) coordinate tracking implementation is attached below! 📄👇 #DSA #Java #LeetCode #Simulation #Optimization #Complexity #63DayStreak #LearningInPublic

🚀 #LeetCode Day Problem Solving 🚀 Day-20 📌 Problem: A robot starts at position (0, 0) on a 2D plane. You are given a string moves representing its movement sequence. Each character in the string denotes a move: ➡ 'R' → Right ⬅ 'L' → Left ⬆ 'U' → Up ⬇ 'D' → Down 👉 Your task is to determine whether the robot returns to the origin (0, 0) after completing all moves. Return true if it returns to origin, otherwise false. 🧠 Example 1: Input: moves = "UD" ✅ Output: true 📖 Explanation: Move Up → (0, 1) Move Down → (0, 0) ✔ Robot returns to origin 🧠 Example 2: Input: moves = "LL" ❌ Output: false 📖 Explanation: Move Left → (-1, 0) Move Left → (-2, 0) ❌ Robot does not return to origin 💡 Key Insight: ✔ Count movements: Number of 'U' should equal 'D' Number of 'L' should equal 'R' ✔ OR simulate coordinates: Track (x, y) position 📊 Complexity Analysis: ⏱ Time Complexity: O(n) 📦 Space Complexity: O(1) 🧠 What I Learned: ✔ Simple simulation problems can be solved efficiently ✔ Importance of balancing movements ✔ Good practice for coordinate tracking ✅ Day 20 Completed 🚀 Keep going strong with DSA & consistency 💪 #Leetcode #DSA #ProblemSolving #BitManipulation #CodingJourney #InterviewPreparation #Consistency