chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Easy/2026-04-05-657-Robot-Return-to-Origin/explanation.md

@@ -0,0 +1,30 @@
+# Robot Return to Origin (Easy)
+
+**Problem ID:** 657  
+**Date:** 2026-04-05  
+**Link:** https://leetcode.com/problems/robot-return-to-origin/
+
+## Approach
+
+To solve the "Robot Return to Origin" problem, we can use a straightforward counting approach based on the moves the robot makes. The main idea is to track the net effect of the moves in the vertical and horizontal directions.
+
+### Approach:
+
+1. **Initialization**: Start with two counters, `vertical` and `horizontal`, both initialized to zero. These will represent the net movements in the y-axis and x-axis, respectively.
+
+2. **Iterate through moves**: Loop through each character in the input string `moves`:
+   - If the move is 'U' (up), increment the `vertical` counter by 1.
+   - If the move is 'D' (down), decrement the `vertical` counter by 1.
+   - If the move is 'L' (left), decrement the `horizontal` counter by 1.
+   - If the move is 'R' (right), increment the `horizontal` counter by 1.
+
+3. **Check final position**: After processing all moves, check if both `vertical` and `horizontal` counters are zero. If they are, it means the robot has returned to the origin (0, 0), and we return `true`. Otherwise, return `false`.
+
+### Data Structures:
+- We only need a few integer variables (`vertical` and `horizontal`), which means the space complexity is O(1).
+
+### Complexity:
+- **Time Complexity**: O(n), where n is the length of the `moves` string. We need to iterate through the string once.
+- **Space Complexity**: O(1), since we are using a constant amount of space regardless of the input size.
+
+This approach efficiently determines if the robot returns to the origin by simply counting the net movements in each direction, making it optimal for the problem constraints.

Easy/2026-04-05-657-Robot-Return-to-Origin/solution.java

@@ -0,0 +1,25 @@
+class Solution {
+    public boolean judgeCircle(String moves) {
+        int horizontal = 0;
+        int vertical = 0;
+
+        for (char move : moves.toCharArray()) {
+            switch (move) {
+                case 'U':
+                    vertical++;
+                    break;
+                case 'D':
+                    vertical--;
+                    break;
+                case 'L':
+                    horizontal--;
+                    break;
+                case 'R':
+                    horizontal++;
+                    break;
+            }
+        }
+
+        return horizontal == 0 && vertical == 0;
+    }
+}

Easy/2026-04-05-657-Robot-Return-to-Origin/solution.js

@@ -0,0 +1,10 @@
+var judgeCircle = function(moves) {
+    let x = 0, y = 0;
+    for (let move of moves) {
+        if (move === 'U') y++;
+        else if (move === 'D') y--;
+        else if (move === 'L') x--;
+        else if (move === 'R') x++;
+    }
+    return x === 0 && y === 0;
+};

Easy/2026-04-05-657-Robot-Return-to-Origin/solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def judgeCircle(self, moves: str) -> bool:
+        return moves.count('U') == moves.count('D') and moves.count('L') == moves.count('R')

README.md

@@ -414,3 +414,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2026-04-02 — [Maximum Amount of Money Robot Can Earn](https://leetcode.com/problems/maximum-amount-of-money-robot-can-earn/) (Medium) → `Medium/2026-04-02-3418-Maximum-Amount-of-Money-Robot-Can-Earn`
 - 2026-04-03 — [Maximum Walls Destroyed by Robots](https://leetcode.com/problems/maximum-walls-destroyed-by-robots/) (Hard) → `Hard/2026-04-03-3661-Maximum-Walls-Destroyed-by-Robots`
 - 2026-04-04 — [Decode the Slanted Ciphertext](https://leetcode.com/problems/decode-the-slanted-ciphertext/) (Medium) → `Medium/2026-04-04-2075-Decode-the-Slanted-Ciphertext`
+- 2026-04-05 — [Robot Return to Origin](https://leetcode.com/problems/robot-return-to-origin/) (Easy) → `Easy/2026-04-05-657-Robot-Return-to-Origin`