# Essays/The Ball Clock Problem

This article discusses Problem #1 in the Finals of the 1995 ACM International Collegiate Programming Contest sponsored by Microsoft.

## The Problem

Tempus et mobilius      Tempus est mensura motus rerum mobilium.
Time and motion         Time is the measure of movement.
— Auctoritates Aristotelis

… and movement has long been used to measure time. For example, the ball clock is a simple device which keeps track of the passing minutes by moving ball-bearings. Each minute, a rotating arm removes a ball bearing from the queue at the bottom, raises it to the top of the clock and deposits it on a track leading to indicators displaying minutes, five-minutes and hours. These indicators display the time between 1:00 and 12:59, but without “a.m.” or “p.m.” indicators. Thus 2 balls in the minute indicator, 6 balls in the five-minute indicator and 5 balls in the hour indicator displays the time 5:32.

Unfortunately, most commercially available ball clocks do not incorporate a date indication, although this would be simple to do with the addition of further carry and indicator tracks. However, all is not lost! As the balls migrate through the mechanism of the clock, they change their relative ordering in a predictable way. Careful study of these orderings will therefore yield the time elapsed since the clock had some specific ordering. The length of time which can be measured is limited because the orderings of the balls eventually begin to repeat. Your program must compute the time before repetition, which varies according to the total number of balls present.

### Operation of the Ball Clock

Every minute, the least recently used ball is removed from the queue of balls at the bottom of the clock, elevated, then deposited on the minute indicator track, which is able to hold four balls. When a fifth ball rolls on to the minute indicator track, its weight causes the track to tilt. The four balls already on the track run back down to join the queue of balls waiting at the bottom in reverse order of their original addition to the minutes track. The fifth ball, which caused the tilt, rolls on down to the five-minute indicator track. This track holds eleven balls. The twelfth ball carried over from the minutes causes the five-minute track to tilt, returning the eleven balls to the queue, again in reverse order of their addition. The twelfth ball rolls down to the hour indicator. The hour indicator also holds eleven balls, but has one extra fixed ball which is always present so that counting the balls in the hour indicator will yield an hour in the range one to twelve. The twelfth ball carried over from the five-minute indicator causes the hour indicator to tilt, returning the eleven free balls to the queue, in reverse order, before the twelfth ball itself also returns to the queue.

### Input

The input defines a succession of ball clocks. Each clock operates as described above. The clocks differ only in the number of balls present in the queue at one o’clock when all the clocks start. This number is given for each clock, one per line and does not include the fixed ball on the hours indicator. Valid numbers are in the range 27 to 127. A zero signifies the end of input.

### Output

For each clock described in the input, your program should report the number of balls given in the input and the number of days (24-hour periods) which elapse before the clock returns to its initial ordering.

30 45 0

### Output for the Sample Input

30 balls cycle after 15 days.
45 balls cycle after 378 days.

## A Solution in J

The balls are assumed to be labeled with the integers i.n . The clock period, the number of elapsed days before the clock repeats, can be computed as follows:

```m    =: >@(0&{)
v    =: >@(1&{)
h    =: >@(2&{)
qu   =: >@(3&{)
z    =: i.@0:
ret  =: |.@}:
init =: z;z;z;i.
f1m  =: (m,{.@qu);v;h;}.@qu
f5m  =: (z;(v,{:@m);h;qu,ret@m) @ (f1m^:5)
f1h  =: (z;z;(h,{:@v);(qu,ret@v)) @ (f5m^:12)
f12h =: (z;z;z;qu,ret@h,{:@h) @ (f1h^:12)
perm =: qu @ f12h @ init
ord  =: *./ @ (#&>"_) @ C.
days =: -: @ ord @ perm
```

The basic data structure is a 4-element list of boxes (m;v;h;qu) of the balls in the minute, 5-minute, and hour tracks and in the queue. (The fixed ball in the hour track is ignored.) Verb init initializes the clock: all tracks are empty and all balls are in the queue. Verb f1m models the clock action every minute; f5m models the clock action every 5 minutes (including the action every minute); f1h models the clock action every hour; and f12h models the clock action every 12 hours.

At the end of 12 hours, all tracks are empty and all balls are in the queue; therefore, the action of the clock is a permutation of the balls, computed by the verb perm . The order of this permutation is the LCM of the cycle lengths of the permutation, representing the number of 12-hour periods to return to the identity, and the clock period is half this number. The following examples illustrate the internal workings of the algorithm:

```   days 45
378
] s=: init 45            NB. Initial state for 45 balls (m;v;h;qu)
┌┬┬┬──────────────────────┐
││││0 1 2 3 4 ... 42 43 44│
└┴┴┴──────────────────────┘
f1m s                    NB. after 1 minute
┌─┬┬┬────────────────────┐
│0│││1 2 3 4 ... 42 43 44│
└─┴┴┴────────────────────┘
f5m s                    NB. after 5 minutes
┌┬─┬┬────────────────────────────┐
││4││5 6 7 8 ... 42 43 44 3 2 1 0│
└┴─┴┴────────────────────────────┘
f1h s                    NB. after 1 hour
┌┬┬──┬─────────────────────────────────────────────────┐
│││16│15 23 22 21 20 28 27 26 25 33 32 31 30 38 37 ... │
└┴┴──┴─────────────────────────────────────────────────┘
f5m^:6 s                 NB. after 30 minutes
┌┬───────────────┬┬──────────────────────────────────┐
││4 9 14 19 24 29││30 31 32 33 34 35 36 37 38 39 ... │
└┴───────────────┴┴──────────────────────────────────┘
f1m^:2 f5m^:6 f1h^:5 s   NB. after 5 hours and 32 minutes
┌────┬──────────────┬─────────────┬───────────────────┐
│21 2│8 24 4 5 43 11│16 36 22 1 23│32 41 33 17 26 ... │
└────┴──────────────┴─────────────┴───────────────────┘

] p=: perm 45            NB. the queue after 12 hours for 45 balls
25 30 0 24 35 2 44 33 15 19 13 6 29 43 8 26 40 31 ...
_5]\ p                   NB. display in 5 columns
25 30  0 24 35
2 44 33 15 19
13  6 29 43  8
26 40 31 12  7
38 28  3 42 32
41 14  5 37 39
4 21 20 11 17
34 18 27 10 23
1 22 36 16  9
C. p                     NB. cycles of this permutation
┌──────────┬────────────┬────────────┬─────────────────┐
│26 14 8 15│42 36 18 ...│43 16 40 ...│44 9 19 7 33 11 6│
└──────────┴────────────┴────────────┴─────────────────┘

,. C. p                  NB. column display of circles
┌──────────────────────────────────────────────────────────────────────────┐
│26 14 8 15                                                                │
├──────────────────────────────────────────────────────────────────────────┤
│42 36 18 12 29 39 23                                                      │
├──────────────────────────────────────────────────────────────────────────┤
│43 16 40 1 30 4 35 34 17 31 21 28 37 27 5 2 0 25 41 22 3 24 32 20 38 10 13│
├──────────────────────────────────────────────────────────────────────────┤
│44 9 19 7 33 11 6                                                         │
└──────────────────────────────────────────────────────────────────────────┘
#&> C. p                 NB. cycle lengths
4 7 27 7
*./ 4 7 27 7             NB. LCM of cycle lengths
756
days 45                  NB. # days is half the # of 12-hour periods
378

d=: days"0[27+i.101      NB. Clock periods for 27 to 127 balls
,"(2) _5 ]\ (2 1\$' '),' ',.~":,.d
23     76    102
15     85     65    138     91
12    117    120    345     35
37    217    114    110    105
378    126   6270     12    513
1116    770     86     51     30
693    180    930    559    858
495  11067    714    455    378
84    105     12    236   7095
255     60   4524   3848   1530
1955    268    714  25389   1155
9360   2006    805   4446   1122
540     36    570   1026  11033
1218   6580    312    301   3367
42780   2550    550   1365   6630
105    861   4514    291   3960
1464   1577   4284   5187    126
17094  15330   1785  43890  25872
5762   3325    204   3420  78120
1224    776    273 108855    174
14430  80080   2415
```

## Permutation Power and Log

Given the current reading (m;v;h;qu) of the clock, can one determine the elapsed time since the initial operation of the clock? (Assuming that the clock has not yet repeated.)

If p is a permutation and k is an integer, the phrase q=:p&{^:k i.#p applies p to the identity permutation k times, obtaining q . By analogy with ordinary multiplication, q is the k-th power of p and (ord p)|k is the log of q relative to p . Determining the elapsed time reduces to finding k=:p log q , where p is the generator permutation of the clock (the state of the queue after 12 hours) and q is the current permutation (the state of the queue at the next even 12-hour). We proceed as follows:

First, compute the residue of q in each of the cycles of p . For example, 1 2 3 4 5 0 consists of a single cycle and 2 3 4 5 0 1 is at 2 relative to that cycle. In general, the residue of q relative to a cycle c is  _1+m-((>c){q)i.{:>c [ m=:#>c ; moreover, if q is a power of p , the result of q indexed by the cycle, (>c){q , must be a rotation of the cycle. For example:

```   p=: 2 3 4 5 6 7 8 1 9 0
q=: 6 3 8 5 9 7 0 1 2 4
C. p
┌───────┬───────────┐
│7 1 3 5│9 0 2 4 6 8│
└───────┴───────────┘

] c0=: 0{C. p		   ] c1=: 1{C. p
┌───────┐                       ┌───────────┐
│7 1 3 5│                       │9 0 2 4 6 8│
└───────┘                       └───────────┘
(>c0){q			   (>c1){q
1 3 5 7				4 6 8 9 0 2
{:>c0			   {:>c1
5				8
1 3 5 7 i. 5			   4 6 8 9 0 2 i. 8
2				2
] m0=: #>c0			   ] m1=: #>c1
4				6
_1+m0-((>c0){q)i.{:>c0	   _1+m1-((>c1){q)i.{:>c1
1				3
```

The preceding computations can be encapsulated as follows:

```assert=: 13!:8@(12"_)^:-.
res1  =: <:@#@[ - { i. {:@[
chkr  =: [: assert { -: res1 |. [
res   =: res1 [ chkr
mr    =: #&>@[ ,. (res&> <)

(>c0) res q		    NB. Residue in cycle 0
1
(>c1) res q		    NB. Residue in cycle 1
3
(C. p) mr q		    NB. Moduli and residues
4 1
6 3
assert 1                 NB. Return 1 if the argument is 1
1
assert 0                 NB. Signal error if the argument is 0
|assertion failure
|       assert 0
(C. p) mr i.-10          NB. Not a power of p
|assertion failure
|   (C.p)    mr i.-10
```

The verb mr produces a 2-column table of moduli (cycle lengths) and residues. p log q obtains from this table by application of the GCD algorithm discovered by Euclid in 300 B.C. and the Chinese Remainder Theorem by Sun Tsu in 350 A.D. (Graham, Knuth, and Patashnik [1988]; Iverson [1995]). The Euclidean algorithm produces a and b such that (m+.n)=(a*m)+b*n , and the Chinese Remainder Theorem specifies that d=:(m*.n)|(m+.n)%~(r*b*n)+s*a*m satisfies r=m|d and s=n|d , for moduli m and n and residues r and s obtained from a power of p .  If cr is a verb such that (m,r)cr(n,s) produces (m*.n),d , then the answer that we seek is k=:{:cr/t .

As indicated, the GCD is computed as a linear combination of the arguments; the algorithm operates by repeated remaindering. Thus:

```g0  =: , ,. =@i.@2:
it  =: {: ,: {. - {: * <.@%&{./
gcd =: (}.@{.) @ (it^:(*@{.@{:)^:_) @ g0

32 gcd 44                NB. GCD as coefficients
_4 3
+/ _4 3 * 32 44          NB. The actual GCD
4
] a=: 32 g0 44           NB. Initial argument for GCD
32 1 0
44 0 1
it a                     NB. One iteration
44 0 1
32 1 0
it it a                  NB. Two iterations
32  1 0
12 _1 1
<"2 it^:(i.6) a          NB. All iterations; stop when 0= lower left corner
┌──────┬──────┬───────┬────────┬───────┬───────┐
│32 1 0│44 0 1│32  1 0│12 _1  1│8  3 _2│4 _4  3│
│44 0 1│32 1 0│12 _1 1│ 8  3 _2│4 _4  3│0 11 _8│
└──────┴──────┴───────┴────────┴───────┴───────┘
```

The verb it applies to a 2-by-3 matrix: column 0 are the two current remainders; columns 1 and 2 are the corresponding coefficients in terms of the original arguments. At each step, a new remainder is computed by using row 1 as the divisor, and the iteration stops when the divisor is zero.

The version of Chinese Remainder used here rejects residues not obtainable from a power of p . Thus:

```ab    =: |.@(gcd/ * [ % +./)@(,&{.)
cr1   =: [: |/\ *.&{. , ,&{: +/ .* ab
chkc  =: [: assert ,&{: -: ,&{. | {:@cr1
cr    =: cr1 [ chkc

4 1 cr 6 3               NB. Applies to (modulus,residue) pairs
12 9                        NB. Produces (LCM, remainder)

4|9                      NB. Verify residue 0
1
6|9                      NB. Verify residue 1
3
c0=: <i.4                NB. A 4-cycle
c1=: <4+i.6              NB. A disjoint 6-cycle
] p=: C. c0,c1           NB. the perm. whose cycles are c0 and c1
1 2 3 0 5 6 7 8 9 4
] q=: c0 C. i.10         NB. One application of cycle c0
1 2 3 0 4 5 6 7 8 9
(C. p) mr q              NB. Moduli and residues
4 1
6 0
4 1 cr1 6 0              NB. Chinese remainder says answer is 3,
12 3                        NB. but 1~:4|3 and 0~:6|3
4 1 cr 6 0               NB. Chinese remainder with built-in check
|assertion failure
|   4 1     cr 6 0
```

The power and log of a permutation are now defined, together with examples which illustrate their workings:

```pow   =: i.@#@[ C.~ (#&>@C.@[|]) # C.@[
log   =: {: @ (cr/) @ (C.@[ mr ])

p=: 4 17 7 18 10 11 0 13 8 16 9 6 15 19 12 14 3 1 2 5
p log i.20
0
p log p
1
p log p{p
2
p log p{p{p
3
p log p pow 3
3
] c=: C. p               NB. the cycles of p
┌─┬────────┬────┬─────────────────────────────────┐
│8│15 14 12│17 1│19 5 11 6 0 4 10 9 16 3 18 2 7 13│
└─┴────────┴────┴─────────────────────────────────┘
ord p                    NB. the order of p; LCM of the cycle lengths
42
p log /:p                NB. the log of the inverse is 1 less than the order
41
] q=: p pow 38           NB. a power of p
19 1 9 4 5 2 13 16 8 6 11 7 14 3 15 12 0 17 10 18
p log q
38
c mr q                   NB. moduli and residues of q in each cycle
1  0
3  2
2  0
14 10
cr/ c mr q               NB. order & log by repeated Chinese Remainder
42 38
{: cr/ c mr q            NB. Select last item
38

k -: p log"1 p pow"1 0 k=.i.ord p  NB. Verify all powers
1
p log ?~#p               NB. A random perm. is unlikely to be a power
|assertion failure	    NB. (probability (ord p)%!#p )
|   p     log?~#p
```

The verb pow exploits the dyad x C. y , which permutes y by the cycles x . Although the definition is less direct than p&{^:k i.#p , the time required is exponentially less. Thus:

```   p=: ?.~600               NB. A random permutation of length 600
c=: C. p                 NB. the cycles of p
#&> c                    NB. cycle lengths
1 25 50 106 252 50 116
ord p                    NB. order (LCM of cycle lengths)
9683100

] k=: ?. ord p           NB. a random power
7758246
(#&>c) | k               NB. the residues of k modulo the cycle lengths
0 21 46 0 174 46 50
NB. Apply each cycle the residue # of times
(p pow k) -: (i.#p) C.~ 0 21 46 0 174 46 50#c
1

(/:p) -: p pow _1        NB. works on all integer powers
1
(i.#p) -: p pow 0
1
(p pow j) -: p pow n+j=:?n=:ord p
1

pow1=:{^:(]`(i.@#@[))    NB. alternative definition p&{^:k i.#p

timer=: 6!:2
timer 'q0=: p pow k'
0.00348536
timer 'q1=: p pow1 k'
115.285
```

That is, 3.5 milliseconds versus approximately 1 minute 45 seconds. Finally, to give a sense of the relative times required for pow and log :

```   timer 'j=: p log q0'
0.00424439
j=k
1
```

## References

• ACM, 1995 ACM International Collegiate Programming Contest Finals, Problem 1, 1995.
• Graham, Ronald L., Donald E. Knuth, and Oren Patashnik,

Concrete Mathematics: A Foundation for Computer Science, Addison-Wesley, 1988 5.

• Iverson, Kenneth E., Concrete Math Companion, Iverson Software Inc., 1995 6.

## Appendix: Collected Definitions

```NB. Clock Period
m     =: >@(0&{)
v     =: >@(1&{)
h     =: >@(2&{)
qu    =: >@(3&{)
z     =: i.@0:
ret   =: |.@}:
init  =: z;z;z;i.
f1m   =: (m,{.@qu);v;h;}.@qu
f5m   =: (z;(v,{:@m);h;qu,ret@m) @ (f1m^:5)
f1h   =: (z;z;(h,{:@v);(qu,ret@v)) @ (f5m^:12)
f12h  =: (z;z;z;qu,ret@h,{:@h) @ (f1h^:12)
perm  =: qu @ f12h @ init
ord   =: *./ @ (#&>"_) @ C.
days  =: -: @ ord @ perm

NB. Moduli (Cycle Lengths) and Residues
assert=: 13!:8@(12"_)^:-.
res1  =: <:@#@[ - { i. {:@[
chkr  =: [: assert { -: res1 |. [
res   =: res1 [ chkr
mr    =: #&>@[ ,. (res&> <)

NB. GCD as a Linear Combination
g0    =: , ,. =@i.@2:
it    =: {: ,: {. - {: * <.@%&{./
gcd   =: (}.@{.)@(it^:(*@{.@{:)^:_)@g0

NB. Chinese Remainder
ab    =: |.@(gcd/ * [ % +./)@(,&{.)
cr1   =: [: |/\ *.&{. , ,&{: +/ .* ab
chkc  =: [: assert ,&{: -: ,&{. | {:@cr1
cr    =: cr1 [ chkc

NB. Permutation Power and Log
pow   =: i.@#@[ C.~ (#&>@C.@[|]) # C.@[
log   =: {: @ (cr/) @ (C.@[ mr ])
```

Contributed by Roger Hui. Earlier versions of the text appeared in the Internet news group comp.lang.apl (original thread and follow-up) and in Vector, Volume 12, Number 2, October 1995.