Overflow in intermediate arithmetic
Wrong move: Temporary multiplications exceed integer bounds.
Usually fails on: Large inputs wrap around unexpectedly.
Fix: Use wider types, modular arithmetic, or rearranged operations.
Move from brute-force thinking to an efficient approach using math strategy.
There is a special square room with mirrors on each of the four walls. Except for the southwest corner, there are receptors on each of the remaining corners, numbered 0, 1, and 2.
The square room has walls of length p and a laser ray from the southwest corner first meets the east wall at a distance q from the 0th receptor.
Given the two integers p and q, return the number of the receptor that the ray meets first.
The test cases are guaranteed so that the ray will meet a receptor eventually.
Example 1:
Input: p = 2, q = 1 Output: 2 Explanation: The ray meets receptor 2 the first time it gets reflected back to the left wall.
Example 2:
Input: p = 3, q = 1 Output: 1
Constraints:
1 <= q <= p <= 1000Problem summary: There is a special square room with mirrors on each of the four walls. Except for the southwest corner, there are receptors on each of the remaining corners, numbered 0, 1, and 2. The square room has walls of length p and a laser ray from the southwest corner first meets the east wall at a distance q from the 0th receptor. Given the two integers p and q, return the number of the receptor that the ray meets first. The test cases are guaranteed so that the ray will meet a receptor eventually.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Math
2 1
3 1
Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #858: Mirror Reflection
class Solution {
public int mirrorReflection(int p, int q) {
int g = gcd(p, q);
p = (p / g) % 2;
q = (q / g) % 2;
if (p == 1 && q == 1) {
return 1;
}
return p == 1 ? 0 : 2;
}
private int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
}
// Accepted solution for LeetCode #858: Mirror Reflection
func mirrorReflection(p int, q int) int {
g := gcd(p, q)
p = (p / g) % 2
q = (q / g) % 2
if p == 1 && q == 1 {
return 1
}
if p == 1 {
return 0
}
return 2
}
func gcd(a, b int) int {
if b == 0 {
return a
}
return gcd(b, a%b)
}
# Accepted solution for LeetCode #858: Mirror Reflection
class Solution:
def mirrorReflection(self, p: int, q: int) -> int:
g = gcd(p, q)
p = (p // g) % 2
q = (q // g) % 2
if p == 1 and q == 1:
return 1
return 0 if p == 1 else 2
// Accepted solution for LeetCode #858: Mirror Reflection
struct Solution;
impl Solution {
fn mirror_reflection(mut p: i32, mut q: i32) -> i32 {
while p % 2 == 0 && q % 2 == 0 {
p /= 2;
q /= 2;
}
if p % 2 == 0 {
return 2;
}
if q % 2 == 0 {
return 0;
}
1
}
}
#[test]
fn test() {
let p = 2;
let q = 1;
let res = 2;
assert_eq!(Solution::mirror_reflection(p, q), res);
}
// Accepted solution for LeetCode #858: Mirror Reflection
function mirrorReflection(p: number, q: number): number {
const g = gcd(p, q);
p = Math.floor(p / g) % 2;
q = Math.floor(q / g) % 2;
if (p === 1 && q === 1) {
return 1;
}
return p === 1 ? 0 : 2;
}
function gcd(a: number, b: number): number {
return b === 0 ? a : gcd(b, a % b);
}
Use this to step through a reusable interview workflow for this problem.
Simulate the process step by step — multiply n times, check each number up to n, or iterate through all possibilities. Each step is O(1), but doing it n times gives O(n). No extra space needed since we just track running state.
Math problems often have a closed-form or O(log n) solution hidden behind an O(n) simulation. Modular arithmetic, fast exponentiation (repeated squaring), GCD (Euclidean algorithm), and number theory properties can dramatically reduce complexity.
Review these before coding to avoid predictable interview regressions.
Wrong move: Temporary multiplications exceed integer bounds.
Usually fails on: Large inputs wrap around unexpectedly.
Fix: Use wider types, modular arithmetic, or rearranged operations.