Given an analog clock with sweeping hour, minute, and second hands, at what times are the hands most evenly “balanced”– that is, most equally separated in angle?

It’s a standard high school algebra problem to compute all of the times at which just the hour and minute hands are *aligned* on top of each other. And it’s relatively straightforward to show that all *three *hands, including the second hand, are only exactly aligned twice per day, at 12 o’clock. But this problem is different: here, we would like the three angles made by the three hands to be as equal– that is, as close to 120 degrees each– as possible.

As we will see shortly, there is no time at which all three angles are *exactly *120 degrees. (This is another nice exercise to prove just using pencil and paper.) So, how close can we get? This post was an admittedly somewhat frivolous excuse to experiment with SymPy, the Python symbolic mathematics library bundled with SciPy. My approach was pretty brute-force, letting SymPy do all of the heavy lifting with very few lines of code, including evaluating multiple different metrics defining what we mean by “balanced.” (All of the code discussed here is available on GitHub.)

The problem is complicated by the floor functions that would be buried in the cost function if we were to use a single parameter to represent the continuously varying time over the entire 12-hour domain. Instead, let’s divide the domain into 12×60=720 one-minute intervals, each specified by a fixed *integer* hour and minute, and for each, only let the second hand sweep through the single revolution of that one minute of time, computing the resulting three angles between consecutive hands:

```
def hand_positions(hour, minute, second):
"""Return positions in [0, 360) of clock hands."""
r_60 = sym.Rational(60, 1)
return (360 * (hour + minute / r_60 + second / (r_60 * r_60)) / 12,
360 * (minute + second / r_60) / r_60,
360 * second / r_60)
def hand_angles(hands):
"""Return angles between clock hands."""
x, y, z = sorted(hands)
return (y - x, z - y, x - z + 360)
```

At any given time, what yardstick should we use to measure how “balanced” the clock hands are? There are at least a couple of reasonable alternatives, even if we restrict our attention to (piecewise) linear cost functions. The first that occurred to me was to “maximize the minimum” angle: by the pigeonhole principle, at least one of the angles is at most 120 degrees, so let’s try to make that smallest angle as large as possible, measuring the deficit:

```
def max_min(*time):
"""(120 minus) minimum angle between clock hands."""
return 120 - min(hand_angles(hand_positions(*time)))
```

Rather than maximizing the minimum angle, another option is to “minimize the maximum” absolute *deviation *of each angle from the desired optimal 120 degrees. This cost is implemented below. (I had initially also implemented the Manhattan distance, i.e., the sum (or equivalently, the average) of absolute deviations from 120 degrees. But it’s another nice problem to show that this is unnecessary: the *sum *of absolute deviations yields the same ordering as the *maximum *of absolute deviations… but this would not generally be true if our clocks somehow had more than just three hands (why?).)

```
def min_max(*time):
"""Max. deviation from 120 deg. of angles between clock hands."""
return max(abs(a - 120) for a in hand_angles(hand_positions(*time)))
```

At this point, the key observation is that the only possible candidate times at which these cost functions are optimized are at their critical points (or at endpoints of the domain). And because these costs are piecewise linear, the critical points are easy to enumerate: either two of the angles are equal (when maximizing the minimum angle), or one of the angles is exactly 120 degrees (when minimizing the absolute deviation). The following function lumps all of these possibilities together into one list:

```
h, m, s = [sym.Symbol(v) for v in 'hms']
def critical_points():
"""Generate possible critical positions of sweeping second hand."""
yield 0
for x, y, z in permutations(hand_positions(h, m, s)):
a, b, c = (y - x, z - y, x - z + 360)
for lhs, rhs in ((a, b), (a, c), (b, c), (a, 120), (b, 120), (c, 120)):
yield from sym.solve(lhs - rhs, [s])
```

The resulting “most balanced” times are shown below. There are a couple of interesting observations. First, a solution won’t be unique; times come in “mirror image” pairs with the same cost. Second, although the two cost functions considered here do yield slightly different optimal times, they differ by less than 3 hundredths of a second, and the same four or five best mirror pairs are all clustered within about 8 hundredths of a second of each other– all at approximately 2:54:34, along with its mirror time 9:05:25.

Finally, what if the second hand doesn’t sweep, but ticks from one integer second to the next? (When I was a kid, this was the magic method to distinguish between the real and fake Rolex watch, neither of which any of us had actually ever seen.) In this case, the most balanced times– that also appear within about a tenth of a second of the nearby overall top ten times– are at 5:49:09, along with its mirror time 6:10:51, as shown below.