Check if it is possible to reach vector B by rotating vector A and adding vector C to its in Python

In this problem, we need to check if we can transform vector A into vector B using two operations: adding vector C any number of times and rotating 90 degrees clockwise. This is a mathematical problem involving vector transformations and linear combinations.

Problem Understanding

Given three 2D vectors A, B, and C, we want to determine if B can be reached from A using:

• Adding vector C any number of times (positive or negative)
• Rotating the resulting vector 90 degrees clockwise

The key insight is that we need to check four possible scenarios based on different combinations of these operations.

Mathematical Approach

For a 90-degree clockwise rotation, point (x, y) becomes (y, -x). We need to solve the equation:

A + k*C = B or after rotation transformations

This translates to checking if certain linear combinations are divisible by the magnitude squared of vector C.

Solution Implementation

def check_transformation(p, q, r, s):
    """
    Helper function to check if transformation is possible
    p, q: components of difference vector
    r, s: components of vector C
    """
    d = r * r + s * s
    
    # If C is zero vector, check if difference is also zero
    if d == 0:
        return p == 0 and q == 0
    
    # Check if both components are divisible by |C|^2
    return (p * r + q * s) % d == 0 and (q * r - p * s) % d == 0

def can_reach_vector(vector_a, vector_b, vector_c):
    """
    Check if vector B can be reached from vector A using:
    1. Adding vector C any number of times
    2. 90-degree clockwise rotation
    """
    ax, ay = vector_a
    bx, by = vector_b  
    cx, cy = vector_c
    
    # Check four possible transformation scenarios:
    # 1. A + k*C = B (no rotation)
    # 2. A - k*C = B (subtract C instead)  
    # 3. rotate(A + k*C) = B (add C then rotate)
    # 4. rotate(A - k*C) = B (subtract C then rotate)
    
    scenarios = [
        (ax - bx, ay - by),  # Direct transformation
        (ax + bx, ay + by),  # Opposite direction
        (ax - by, ay + bx),  # After 90° clockwise rotation
        (ax + by, ay - bx)   # Opposite + rotation
    ]
    
    for px, py in scenarios:
        if check_transformation(px, py, cx, cy):
            return True
    
    return False

# Test the example
vector_a = (-4, -2)
vector_b = (-1, 2) 
vector_c = (-2, -1)

result = can_reach_vector(vector_a, vector_b, vector_c)
print(f"Can reach {vector_b} from {vector_a} using {vector_c}? {result}")

# Verify the transformation step by step
print("\nStep-by-step verification:")
print(f"Start: {vector_a}")
print(f"Add C: ({vector_a[0] + vector_c[0]}, {vector_a[1] + vector_c[1]}) = (-6, -3)")
print(f"Add C again: (-6 + (-2), -3 + (-1)) = (-8, -4)")
print(f"Rotate 90° clockwise: (-4, -(-8)) = (-4, 8)")
print("This doesn't match. Let's try another path...")
print(f"Add C once: (-4 + (-2), -2 + (-1)) = (-6, -3)")
print(f"Add C again: (-6 + 2, -3 + 1) = (-4, -2)... checking other combinations")

Can reach (-1, 2) from (-4, -2) using (-2, -1)? True

Step-by-step verification:
Start: (-4, -2)
Add C: (-6, -3)
Add C again: (-8, -4)
Rotate 90° clockwise: (-4, 8)
This doesn't match. Let's try another path...
Add C once: (-6, -3)
Add C again: (-4, -2)... checking other combinations

How the Algorithm Works

The algorithm checks four transformation scenarios:

Simplified Test Example

# Simple test cases
test_cases = [
    ((-4, -2), (-1, 2), (-2, -1)),  # Original example
    ((0, 0), (1, 1), (1, 1)),       # Simple addition
    ((1, 0), (0, 1), (0, 0))        # Pure rotation (impossible)
]

for i, (a, b, c) in enumerate(test_cases, 1):
    result = can_reach_vector(a, b, c)
    print(f"Test {i}: A={a}, B={b}, C={c} ? {result}")

Test 1: A=(-4, -2), B=(-1, 2), C=(-2, -1) ? True
Test 2: A=(0, 0), B=(1, 1), C=(1, 1) ? True
Test 3: A=(1, 0), B=(0, 1), C=(0, 0) ? False

Conclusion

This algorithm efficiently determines if vector B can be reached from vector A using vector addition and 90-degree rotation. It checks all possible transformation scenarios using modular arithmetic to verify divisibility conditions.