1. The number the code returns

The greatest common divisor of two positive whole numbers $a$ and $b$, written $\gcd(a, b)$, is the largest whole number that divides both with no remainder. The problem asks for $\gcd(\text{hi}, \text{lo})$, where lo is the smallest value of nums and hi is the largest. findGCD finds the two ends with min and max, and gcd computes their greatest common divisor.

2. One step of Euclid's algorithm

Divide $a$ by $b$: $a = q \cdot b + r$, where $q = \lfloor a / b \rfloor$ is the quotient and $r = a \bmod b$ is the remainder, with $0 \le r < b$. Euclid's algorithm replaces the pair $(a, b)$ with $(b, r)$ and repeats:

$\gcd(a, b) = \gcd(b,\ a \bmod b) \qquad \gcd(a, 0) = a$

3. Why one step keeps the answer, and why the loop ends

The common divisors stay the same. Take any $d$ that divides both $a$ and $b$. Then $d$ divides $r = a - q \cdot b$, because it divides both terms. So $d$ divides $b$ and $r$. In the other direction, take any $d$ that divides $b$ and $r$. Then $d$ divides $a = q \cdot b + r$. So the pairs $(a, b)$ and $(b, r)$ have exactly the same common divisors. The largest of them, the gcd, is the same too.

The loop ends. The new second number is $r < b$. So the second number shrinks in every step and stays at 0 or above. It reaches 0 after a finite number of steps. At that point the pair is $(a, 0)$, and $\gcd(a, 0) = a$.

It ends fast. Every two steps at least halve the first number. So the loop runs $O(\log M)$ times, where $M$ is the larger value. For values up to 1000, the most steps any pair needs is 14, for the pair $(987, 610)$. These two numbers are neighbours in the Fibonacci sequence, the worst case for Euclid's algorithm.

4. Both values change at once, and the order of the arguments

a, b = b, a % b computes the right side first, with the old a and b, and then assigns both. Two separate lines, a = b then b = a % b, would compute b % b, which is always 0. The loop would then stop after one step and return the old b.

The code calls gcd(hi, lo), with the larger value first. With the smaller value first, the answer is still right. The first step only swaps the two, because lo % hi is lo when lo < hi. For example, gcd(3, 8) first becomes gcd(8, 3), one extra step.

When the smallest and largest values are equal, as in [3,3], the first step gives $3 \bmod 3 = 0$. The code returns 3, the value itself.

5. Example 1 by hand

nums = [2,5,6,9,10], so lo = 2 and hi = 10. The call is gcd(10, 2).

Now b is 0, so the loop stops and returns a = 2, the expected output. The values 5, 6 and 9 play no part.

6. Example 2 by hand

nums = [7,5,6,8,3], so lo = 3 and hi = 8. The call is gcd(8, 3).

The loop returns a = 1, the expected output. By part 3, every pair in the table has the same common divisors as $(8, 3)$, and the last pair $(1, 0)$ shows that the only one is 1.

7. From the math to the code

Finding min and max reads all $N$ values, and Euclid's loop takes $O(\log M)$ steps. So the code takes $O(N + \log M)$ time and $O(1)$ space, as its docstring says.