Vector Magnitude

The magnitude (Euclidean norm) of a vector is computed by squaring each component, summing those squares, and taking the square root of the sum.

---

1. Background Knowledge

A vector in this context is an ordered list of numbers, often written as $\mathbf{v} = [v_1, v_2, \dots, v_n]$. You can think of it as a point in $n$‑dimensional space, or as an arrow from the origin to that point.

The Euclidean norm (or magnitude or length) of a vector generalizes the Pythagorean theorem to higher dimensions. For 2D, the length of $(x, y)$ is $\sqrt{x^2 + y^2}$; for 3D, the length of $(x, y, z)$ is $\sqrt{x^2 + y^2 + z^2}$. In $n$ dimensions, this becomes:

$$\|\mathbf{v}\| = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}$$

This quantity is heavily used in normalization (scaling a vector to have length 1) and in distance computations (the distance between two points is the norm of their difference).

---

2. Algorithm / General Approach

The algorithm pattern is:

1. Iterate over all vector components.
2. Accumulate the sum of their squares.
3. Take the square root of the final sum to get the magnitude.

This is a simple single-pass reduction (fold) over the elements of the vector.

---

3. Step-by-Step Strategy

Assuming the input is a list/array v of length n:

1. Initialize an accumulator:

sum_sq = 0.0

2. For each component x in v:

• Square it and add to the accumulator:

sum_sq += x * x

3. After the loop, compute the square root:

magnitude = math.sqrt(sum_sq)

4. Return or print magnitude.

In pseudocode:

function vector_magnitude(v):
 sum_sq = 0
 for each x in v:
 sum_sq = sum_sq + x * x
 return sqrt(sum_sq)

---

4. Common Pitfalls

• Forgetting the square root: Summing squares alone gives you the squared norm, not the magnitude.
• Integer vs float:
• If components or the accumulator are integers, you might lose precision.
• Use floating-point (e.g., double / float) for sum_sq and the result.
• Empty vector:
• If the problem allows it, the norm of an empty vector is usually defined as 0; otherwise, the input will typically guarantee at least one element.
• Overflow for large values (less of a concern in Easy problems, but worth noting):
• Squaring large integers can exceed integer range; using floating-point can help in practice.

---

5. Time & Space Complexity

• Time complexity: You process each of the $n$ components once, so time complexity is $O(n)$

• Space complexity: Aside from the input, you only keep a few scalar variables (sum_sq, magnitude), so space complexity is $O(1)$