Rem, M.

Elsevier - Publisher Connector 

Small programming exercises 4 

Science of Computer Programming 4 (1984) 323-333 
North-Holland 
323 
SMALL PROGRAMMING EXERCISES 5 
M. REM 
Department of Mathematics and Computing Science, Eindhoven University of Technology, 
5600 MB Eindhoven. 7he Netherlands 
Fibolucci revisited 
The Fibolucci Problem (Exercise 2) allows a much more efficient solution than 
the one presented in Small Programming Exercises 2. This was pointed out to me 
by Jan Tijmen Udding. Recall the definition of function f: f(0) = 1, f( 1) = 1, and 
for ma0 
f(m+2)=X*f(m)+ Y*f(m+l). 
Let, for m 3 0, r(m) denote 
(Si:O=ZiSm:f(i)*f(m-i)). 
The exercise is to compute r( IV). We have r(0) = 1, r( 1) = 2, and, as may be checked 
easily, for m 3 0 
r(m+2)=X* r(m)+ Y* r(m+l)+X.f(m)+f(m+l). 
As a consequence, for m Z= 0
Hence, 
Since a 4 xCmatrix may be raised to the Nth power in a time proportional to log N, 
determining r(N) requires only logarithmic time. In Small Programming Exercises 
2 a linear solution was presented. 
0167-6423/84/$3.00 @ 1984, Elsevier Science Publishers B.V. (North-Holland) 
324 M. Rem 
Graph computations 
Our new exercises are computations on graphs. We look at some elementary 
exercises this time and save a few more difficult ones for the next issue. 
We distinguish directed and undirected graphs. Both consist of a finite set, whose 
elements are called vertices, and a binary relation on that set. In undirected graphs 
this relation is symmetric and irreflexive. We say that there is an edge between 
vertices x and y of an undirected graph if the relation holds for (x, y)-and, 
consequently, for (y, x). The irreflexivity expresses that undirected graphs have no 
edges between a vertex and that same vertex. 
We now turn to directed graphs. If the relation holds for pair (x, y) of vertices 
we say that the graph has an arc from x to y. Vertex y is then called a successor of 
x, and x a predecessor of y. A path is a sequence r+,, u,, - . . , u, of vertices, 12 0, 
such that for all i, 0 s i < Z, Vi is a predecessor of vi+,. It is a path from u,, to uI and 
it has length I. We say that vertex y is reachable from vertex x if the graph has a 
path from x to y. Notice that every vertex is reachable from itself. 
In order to become acquainted with computations on graphs and with our way 
of representing graphs, we study as an example the problem of determining in a 
directed graph G the set of vertices that are reachable from a given vertex X. 
Graph G is represented by two integer arrays: b(j: 0s j =Z N) and e( i: 0 c i < M). 
N is the number of vertices, and M the number of arcs. The vertices are numbered 
0 through N - 1. Vertexj (0 <j < N) has b( j + 1) - b(j) successors; they are listed- 
in some order-in the segment 
e(i: b(j)si<b(j+l)). 
We have b(0) = 0 and b(N) = M. If a graph G is given in this way by arrays b and 
e we say that assertion suc( G, b, e) holds. If rather than successors the predecessors 
are listed in e we say that PRED( G, b, e) holds. A good exercise to acquaint oneself 
with the graph representation is to write a program that ‘inverts* the arcs of a given 
graph, i.e. to solve S in 
I[N,M:int{N21hM20} 
; bO(j:OsjsN),eO(i:Osi<M): array of int 
{suc( G, 60, eO>} 
; I[ bl(j: O<ja N), el(i: OC i< M): array of int 
; s 
{PRED(G, bl, el)} 
2 
Ihis problem allows a solution that is linear in the number of vertices,,and arcs. 
(Hint: First determine, by inspecting e0, the value of bl and then compute e 1.) 
Problem of the reachable uertices 
We can now formulate the functional specification of our example problem. We 
are requested to determine S in 
Small programming exercires 325 
/[N,M,X:int{N?=lhM~OhO~XXN} 
; b(j:O<j<N),e(i:O<i<M): array of int 
{suc.( G, b, e)) 
;I[ r(j: Osj< N): array of boo1 
; s 
{(Aj:O<j<N:r(j)=(vertex j reachable from X))] 
Solution by tripartitioning 
Very much in the vein of the solution strategy of Exercises 3 through 6 we introduce 
as an invarient 
PO: V2 U R( Vl) = R({X}). 
VI and V2 are sets of vertices, and R(U), for U a set of vertices, denotes the set 
of all vertices that are reachable from a vertex in U. Notice that R(0) = 0 and that 
j E R({ j}) for any vertex j. We have to compute R({X}). 
Invariant PO may be intialized with Vl, V2 = {X}, 0. If Vl = 0 the invariant 
implies that V2 = R({X}), i.e. that the answer is recorded in V2. The guard of the 
repetition is, therefore, Vl f 0. We maintain as an additional invariant that sets VI 
and V2 are disjoint: 
Pl: Vl r-l v2=0. 
Per step of the repetition we wish to move one vertex j E Vl from set VI to set V2: 
VI, V2:= Vl\{j}, V2U{j}. (1) 
This assignemnt does not destroy Pl. If PO holds prior to the execution of (1), then 
afterwards 
V2 U R( Vl) U R({j}) = R({X}) 
holds. Comparing this with PO, we observe that we can subsequently reestablish 
PO by seeing to it that 
R({j})c V2U R( Vl). 
Since je V2, this amounts to establishing 
R(S(j))c V2UR(Vl) 
in which S(j) denotes the set of successors of vertex j. 
Consider each k E S( j j: 
(i) If kE VI U V2 we establish (2) by 
Vl := Vl U {k} 
(2) 
(3) 
an assignment that maintains Pl. 
326 M. Rem 
(ii) If kc Vl condition (2) is satisfied. 
(iii) The case k E V2 requires more care. Condition (2) is satisfied if we extend 
the invariant with 
P2: R(V2)c V2UR(Vl). 
Invariant P2 holds initially. Neither (1) nor (3) destroys P2. 
With PO A Pl A P2 as an invariant the program has the following structure: 
Vl, v2:= {X}, 0 
;do Vl#@ 
+letjE Vl 
; Vl, V2:= Vl\{j}, V2U{j} 
; for each k E S(j): 
ifkgVlUV2+Vl:=VlU{k} 
Cl ke Vl U V2+skip 
fi 
od 
The program terminates, since set V2 grows per step of the repetition. 
We now come to the representation of sets Vl and V2 . In order to determine a 
vertex j E Vl readily, an integer variable nu 1 and an integer array u 1 (j: 0 S j < N) 
are introduced. We maintain as an invariant that nul is the number of vertices in 
Vl and that the vertices in Vl are listed-in some order-in the segment 
ul(j: OSj< nul). 
Given that the selection in the if-construct does not discriminate between Vl and 
V2, we can use boolean array r for the representation of Vl U V2: 
(Aj:OSj<N: r(j)=jE VlU V2). 
For Vl=0 this simplifies to 
,(Aj:Osj<N: r(j)=jE V2) 
which, together with ‘V2 = R({X}), shows that for Vl = 0 the postcondition of the 
specification is indeed satisfied. 
We thus .arrive at the following program text: 
s: I[ nul: int 
; ul(j: OSj< IV): array of int 
; I[ j: int; j:= 0 
;doj#N+r:(j)=(j=X);j:=j+lod 
II 
; nul:= 1; ul: (0)=X 
;donul#O 
-I[ j, i: int 
;j:=ul(nul-l);nul:=nul-1 
Small programming e.rercises 327 
; i:= b(j) 
;doi#b(j+I) 
+l[k: int; k:= e(i) 
;if~r(k)+ul:(nul)=k;nol:=nul+l;r:(k)=tr~e 
0 r(k) + skip 
I/ 
; i:=i+l 
od 
II 
od 
In the inner repetition each arc of G is processed at most once. Therefore, the 
number of steps of the inner repetition is, over the whole computation, bounded 
by the number of arcs. The two other repetitions are bounded by the number of 
vertices of G. The execution time of the program is, consequently, linear in the 
number of vertices and arcs of graph G. 
At any point during the computation the set of vertices is partitioned into three 
(possibly empty) subsets: V2, Vl, and the other vertices. Call these the black vertices, 
the grey vertices, and the white vertices respectively. This tripartitioning of the set 
of vertices is a rather general technique in graph computations. Initially there is 
one grey vertex and all others are white. At every step of the repetition one grey 
vertex is coloured black and all its white successors are coloured grey. In the end 
all reachable vertices are black. Invariant PO expresses that the reachable vertices 
are black or reachable from a grey vertex. The grey vertices, in a sense, represent 
the remaining “colouring obligations”. Invariant P2 expresses that every white 
vertex that is reachable from a black vertex is reachable from a grey vertex as well. 
In general this invariant can be guaranteed to hold by disallowing arcs from black 
to white vertices, a condition satisfied by our solution. 
The three new exercises we present may all be solved by the tripartitioning 
technique. In my solutions, Exercise 11 requires two additional integer arrays, 
Exercise 12 three, and Exercise 13 two integer arrays and a boolean array, all of 
length N. In the program above it is immaterial which grey vertex is coloured black 
at each step of the repetition. (The particular choice made is known as depth-first 
search.) In the three new exercises this choice is arbitrary as well. Just like the 
problem above, they allow solutions that are linear in the number of vertices and 
arcs (edges). In the next issue we will encounter an exercise in which a particular 
grey vertex should be selected. The computation of the selection makes the solution 
of that exercise nonlinear. 
A cycle in a directed graph is a path whose length is at least 1 and of which the 
first and the last vertex are the same. A graph that contains a cycle is called cyclic; 
a graph without a cycle is called acyclic. 
328 M. Rem 
Exercise 11: acyclicity 
Find a statement list S such that 
I[ N,M:int{N~l~M~0} 
; b(j: OSj S IV), e( i: OS i < M): array of int 
{suc(G, b, e)) 
; I[ ac: boo1 
: s 
{ac = (G is acyclic)} 
II 
II 
Exercise 12: a longest path in an acyclic graph 
Each acyclic graph has a finite maximum for the lengths of its paths. The purpose 
of this exercise is to record one of the paths that attains that maximum length. 
Determine a statement list S such that 
; b(j:Osj<N),e(i:04i<M): array of int 
{suc( G, b, e) A G acyclic} 
; I[ k: int 
; p(j: 0Sj-C N): array of int 
; s 
{p(j: 0 =z j < k) records, in order, the vertices of some 
longest path in G} 
II 
II 
The next exercise deals with an undirected graph. Vertices x and y are called 
neighbours if there is an edge between them. Vertex j, 0 <j < N, has b( j-t 1) - b(j) 
neighbours. These neighbours are listed-again, in some order-in the segment 
e( i: b(j) s i < b(j + 1)). If an undirected graph G is given in this way we say that 
NEIGH( G, b, e) holds. Notice that each edge (x, y) is recorded twice: y as a neighbour 
of x, and x as a neighbour of y. The length of array e, consequently, equals twice 
the number of edges of G. A path in an undirected graph is a sequence of vertices 
in which any two successive vertices are neighbours. An undirected graph is called 
connected if there is a path between every two vertices. It is called bipartite if there 
exists a subset of the set of vertices such that every edge has exactly one vertex in 
that subset. 
Exercise 13: checking whether a graph is bipartite 
Find a statement list S such that 
I[ N,M:int{NSlhM~O} 
Small programming e.xerciser 329 
; b(j: 0 sj s N), e( i: 0 S i < M): array of int 
{NEIGH( G, b, e) A G connected} 
; I[ bip: boo1 
: s 
{ bip = (G is bipartite)} 
31 
II 
Solution of Exercise 9 (problem of the mirrors) 
With N mirrors, numbered 0, 1,. . . , N - 1, placed at positions X( i)/2, we have 
to find a statement list S that determines whether there exists a sequence of reflections 
that moves a point from a given position I to a given position J: 
I[ N, I,.!: int (Nz2) 
; X( i: 0s i < N): array of inf {X is increasing} 
; I[ b: boo1 
; s 
{b = “there exists a sequence of reflections from I to J”} 
II 
II 
With p representing the point’s position a reflection in mirror i followed by a 
reflection in mirrorj corresponds to 
p:=X(j)-X(i)+p. 
As a consequence, the possible values of 
(Si:Oci<N: bi*X(i)) (4) 
for (S i: 0 s i < N: bi) = 0, bi integer, are the possible net distances over which a 
point can be moved by an even number of reflections. 
Let, for lsi<N, 
ci = -(S j: 0s j < i: bj). 
Then, as can be checked easily, (4) equals 
(Si: l<i<N: Ci*(X(i)-X(i-1))). (5) 
Consequently, position / is reachable from position I by an even number of 
reflections if and only if there exist integer values ci, 1 c i < N, such that J - I = (5). 
Since the first reflection moves point I to X(h) - I for some h, position J is reachable 
from position I by an odd number of reflections if and only if there exist an h, 
0 c h < N, and integer values ci, 1s i < N, such that 
J-X(h)+Z=(5). (6) 
330 M. Rem 
By incrementing the ci’s for 1 s is h by 1, (5) increases by X(h) - X(0). Con- 
sequently, if there exist Ci’s such that (6) then there also exist ci’s such that 
.Z-X(h)+Z+X(h)-X(O)=(5) 
which equals 
J-x(o)+z=(5) 
Since X is increasing, (5) is a linear combination of positive numbers. There 
is an elementary result from number theory that deals with the expressibility of 
values as linear combinations of positive numbers: 
Let S = {fO, . . . , fk- ,} be a nonempry set of k positive numbers. Then 
(E co,. . . , ck-, :: x=(Si:O~i<k:c,*l;)) 
=(Em ::x=m*gcd(S)) 
(gcd( S) denotes the greatest common divisor of the elements of set S.) Its con- 
sequence is that J is reachable from Z by a sequence of reflections if and only if 
(J-Z)modgcd({X(i)-X(i-1)1l~i<N})=O 
v(.Z-X(O)+Z)modgcd({X(i)-X(i-l)[l<i<N})=O. 
The computation thus boils down to computing this greatest common divisor and 
checking the condition above. 
In the repetition we maintain the invariant 
g=gcd({X(i)-X(i-l)jlci<cj})A2<j<N. 
The variables are initialized at j = 2 and g = X( 1) -X(O). We could choose j # N 
as our guard. However, since once 
(J-Z)modg=Ov(.Z-X(O)+Z)modg=O 
becomes true it remains so, we can strengthen the guard with its negation. We record 
J - Z and _Z - X(0) + Z in local variables JZ and JXZ respectively. 
S: I[ JZ, ZXZ, j, g: int 
;_Zz,_Zxz:=.Z-Z,J-x(o)+z 
;j,g:=2,X(l)-X(0) 
;doj#N~.ZZmodg#O~JXZmodg#O 
+I[ h: int 
; h:=X(j)-X(j-1) 
;doh#O+g,h:=h,gmodhod 
II 
; j:=j+l 
od 
; b:=(JZmodg=OvJXZmodg=O) 
II 
Small programming exercises 331 
Solution of Exercise 10 (largest bounded square) 
It is requested to find a statement list S such that 
I[M,N,X,Y:int{M>lAN>lhX~Y} 
;A(i,j:Osi<lU~h~j<N): array of int 
{(Ai,j:O<i<M-lhO<j<N:A(i,j)sA(i+l,j)) 
h(Ai,j:O<i<&fhO=Gj<N-l:A(i,j)sA(i,j+l))} 
; I[ a: int 
; s 
{a=(MAXh:haO 
A(Ek,f:OGk<M-hAOGl<N-h: BS(k,l,h)): h)} 
II 
II 
inwhich,forO~k~M-h,O~I~N-h,andhLO,BS(SI,h)denotes 
(Ai,j:k~i<k+h~l<j<I+h:XGA(i,j)<Y). 
Just like we did in Exercises 3 through 6 we obtain a function C( m, n) from the 
postcondition. We let m -h be the upper bound of k and n the lower bound of 1, 
i.e.wedefineforOGm<MhOsn<N: 
C(m,n)=(MAXh: hz0 
A(Ek,l:O<kGm-hAn<lGN-h:BS(k,I,h)):h). 
C(m, n) is the largest size of any bounded square in the rectangle 
A(k,l:OGk<mAnsl<N) 
Consider the definition of C(m, n). Since the nonemptyness of the domain of k 
requires h d m, we have 
C(m, n)sm. (7) 
The nonemptyness of the domain of I requires h s N - n. Consequently, 
C(m, n)c N-n. (8) 
Moreover, since BS( k, f, 0) holds, we have C( m, n) 2 0. 
The postcondition is 
a = C( M, 0). 
We adopt, analogous to Exercises 3 through 6, the following invariant. 
P: a max C( m, n) = C( M, 0) 
Aa~Oha~m~MhO~n~N-a. 
The lower bound of m is suggested by the fact that, according to (7), 
a max C(a, n) = a. (9) 
332 M. Rem 
upper bound of n is prompted by the observation that, according to (8), 
amaxC(m, N-a)=a. 
We have thus, by (9) and (lo), 
(10) 
Pn(m=avn=N-a) 3 a=C(kI,O). 
We choose m # a A n # N-u as the guard of the repetition. The repetition may be 
initialized with m, n, u = M, 0,O. In the repetition m is decreased and n + a increased. 
A suitable bound function is, therefore, m + N - n - a. 
Since A is ascending in both arguments, we have for h 2 1 
BS(~,I,~)~A(~,I)~XAA(~+~-~,I+~-~)~Y. (11) 
The program relies on the fact that the three properties below follow from PA m # a A 
nf N-u: 
(i) A(m-1-u,n)<X 3 umaxC(m,n)=amaxC(m,n+l), 
(ii) Afm-l,n+u)>Y 3 umaxC(m,n)=umaxC(m-l,n), 
(iii) A(m-l-u,n)sXhA(m-l,n+u)S Y 3 umaxC(m,n) 
=(u+l)maxC(m,n). 
Before proving the properties above we present the resulting program text. 
S: I[ 172, n: int 
; m, n a := M, 0,O {P} 
;dom#uAn#N-a 
+ if A(m-I-u,n)<X 
+{amaxC(m,n)=amaxC(m,n+l)} n:=n+I 
0 A(m-l,n+a)> Y 
+{amaxC(m,n)=umaxC(m-I,n)} m:=m-1 
OA(m-1-u,n)3XAA(m-l,n+a)sY 
+(umaxC(m,n)=(a+l)maxC(m,n)) u:=a+l 
fi {P) 
od {Ph(m=uvn=N-a) and, hence, u=C(M,O)} 
The bound function m + N - n - a is initially M + N. Since each step of the repetition 
decreaes it by 1, the execution time of the program is linear in M + N. 
Proof of (i): Let h 3 a + 1. According to (11) 
BS(k, n, h) =S A(k, n)zX. (12) 
Assume A(m-1-a,n)<X. For all k such that Osksm-l-a we have then, 
since A is ascending in its first argument, A(k, n) < X and, by (12), lBS(k, n, h). 
a max C(m, n) 
=umaxC(m,n+l)max(MAXh:h~O 
A(Ek:O<kSm-h:BS(k,n,h)):h). 
Small programming exercises 333 
Since~BS(k,n,h)holdsforall0~k~m-l-aand,byh~a+l,forallO~k~ 
m - h, the existential quanti~cation above is false. Consequently, a max C( m, n) = 
a max C(m, n+ 1). 
Proof of (ii): Similar to the proof above. 
Proofof (iii}: From the definition of C(m, n) and the fact that, according to (I I), 
the left-hand side of (iii) implies BS( m - 1 - a, n, a + 1) we conclude C( m, n) 2 a + 1, 
which is equivalent to a max C( m, n) = (a + I ) max C( M, n ). 


Small programming exercises 5 

NARCIS 

Small programming exercises 6

Science of Computer Programming 4 (1984) 205-2 IO 
North-Holland 
205 
SMALL PROGRAMMING EXERCISES 4 
M. REM 
Department of Mathematics and Computing Science, Eindhoven University of Technology, 5600 MB 
Eindhoven. The Netherlands 
We present two new exercises. Exercise 9 requires determining whether, by the 
moves allowed, a certain position is reachable from a given initial position. The 
difficulty of the exercise is that there are infinitely many positions reachable from 
the initial position. However, some analysis of the moves may reveal that a very 
simple algorithm suffices. The work is in this case not in the programming but in 
the analysis of the problem. In that sense it can hardly be called a programming 
exercise. 
Exercise 10 concerns determining, within a matrix that is ascending in both 
arguments, the size of the largest square in which all matrix elements have values 
between two given constants. It is another problem of the type we encountered in 
Exercises 3 through 6. Although it can be solved by the same strategy, it is more 
intricate than these earlier exercises. It allows a solution whose computation time 
is linear in the number of rows and columns of the matrix given. I owe this exercise 
to W.H.J. Feijen. 
Exercise 9: problem of the mirrors 
N mirrors, numbered 0, 1,. . . , N - 1, are placed along the X-axis: mirror i, 
perpendicularly to the axis, at position X(i)/2. A point at the axis may be reflected 
by any of the N mirrors. Reflecting a point in a mirror at distance d from the point 
consists in moving the point over a distance 2d along the axis to the other side of 
the mirror. Given two positions Z and J at the axis, we have to determine whether 
there exists a sequence of reflections that moves a point from position Z to position J: 
I[ N, Z,J: int (Na2) 
; X( i: 0s i c N): array of int {X is increasing} 
;I[b: boo1 
;S 
(b = “there exists a sequence of reflections from Z to Y’} 
0167-6423/84/33.00 @ 1984, Elsevier Science Publishers B.V. (North-Holland) 
206 M. Rem 
Exercise 10: largest bounded square 
With BS(k, 1, h) denoting 
(Ai,j: ksi<k+hhI~j<I+h:X~A(i,j)~ Y) 
it is requested to find a statement list S such that 
I[M,N,X,Y:int{M2lhNz=lAX~Y} 
;A(i,j:O<i<M~O~j<N):arrayofint 
{(Ai,j:Osi<M-l~Osj<N:A(i,j)sA(i+l,j)) 
A(Ai,j:Osi<MAOGj<N-l:A(i,j)cA(i,j+l))) 
; I[ a: int 
;S 
{a=(MAXh:(Ek,I:Ock<M-hAOsI<N-h:BS(k,~,h)):k)} 
II 
II 
Solution of Exercise 7 (regular polygon on a circle) 
With N points on a circle and the arc between points i and (i + 1) mod N having 
length d(i), we have to find a statement list S such that 
I[k,N: int(3skaN) 
;d(i:Osi<N):arrayofint 
{Ai:O~i<N:d(i)~l)~(Si:O~i<N:d(i))modk=0} 
;I[b: boo1 
;S 
{b = “among the N points given there exist k 
points that form a regular k-gon”} 
II 
II 
We first express the postcondition of the functional specification more formally. 
For 0 s j s N define 
D(j)=(Si:Osi<j: d(i)). 
Then, for 0~ j < N, D(j) is the (clockwise) distance along the circle from point 0 
to point j. Let, furthermore, A = B/k, in which B denotes the circumference D(N) 
of the circle. Then A is the length of an arc between any two successive vertices of 
a regular k-gon. We have A 2 1. The values A and B may be determined by 
I[ i: int 
; i, I3 := 0,O 
;doi#N+i,B:=i+l,B+d(i)od 
; A:= B/k 
II 
Small programming exercises 207 
We define a set U of points as follows: 
uo: D(j) < A =+ j E Us 
Ul: in CJAD(~)+A=D(~) + jE U. 
u2: U contains only points that belong to it on account of UO or Ul. 
Then we have for any je U 
(Ah: 0~ h < D(j)div A: (Ei: OS i<j: D(i)+h.A= D(j))). 
With the definitions given, the postcondition of the functional specification is, 
consequently, equivalent to 
b=(Ej:j~ U: D(j)divA=k-1) 
Since D(j) < B = A. k for all points j, this is equivalent to 
b=(Ej: jc U: D(j)+Az B). (1) 
We introduce an auxiliary array w(i: 0 s i < N) in which we record for the points 
j E U the values D(j) +A. For this recording two variables q and r are introduced 
and PO is kept invariant. 
PO: q=(Nj:Osj<r:jE U) 
h(Aj:Osj<rAjEU:(Ei:O<i<q: w(i)=D(j)+A)) 
h(Ai:O<i<q-1: w(i)<w(i+l))hlCq~rC~ 
PO A r = N implies that for all points j E U the values of D(j) +A have been recorded 
in increasing order in w(i: 0~ i < q). Therefore, if r = N variable b may, according 
to (1), be assigned the value of w(q - 1) 5 B. We choose r # N as the guard of the 
repetition and N-r as its bound function. 
Invariant PO is established by recording the values D(j)+A for those points j 
that belong to U on account of UO: (To distinguish the pointwise alteration of the 
value of an array variable from an assignment statement, we write “w:(q) = E” for 
the alteration of w in point q.) 
q, c := 0,O {c = D(q)} 
;doc<A+w:(q)=c+A;q,c:=q+l,c+d(q)od 
; r:=q 
(2) 
As a consequence, we may for all other points j use U 1 to determine whether j E U. 
Program part (2) also establishes 
Pl: c = D(r) 
which we propose to keep invariant as well. 
208 M. Rem 
In the repetition we wish to increase r by 1. According to PO:,, this involves 
determining whether r e U, i.e., according to U I, whether 
(Ei: 0~ i < q: w(i) = D(r)). (3) 
Since D(r - 1) < D(r), w(i) > D(r - I) is a necessary condition for w(i) = D(r). We 
introduce a variable p and maintain PO A PI A P2 as an invariant. 
P2: p=(MINi:O~i<q~w(i)>D(r-I): i)minq 
Then, given Pl A P2, (3) is equivalent to 
(Ei:psi<q: w(i)=c). (4) 
Program part (2) establishes D(r - 1)~ As D(r). Since w(0) = A, P2 may then be 
initialized by assigning to p the value 0. Notice that P2 implies p c q. 
Since in the repetition r is increased by 1, it involves establishing P2:+,, which, 
given Pl, may be written as 
p=(MINi:O~i<qAw(i)>c: i)minq 
This is achieved by a linear search, which we guarantee to terminate by first making 
w(q) equal to c +A. If in the course of that search w(p) = c then, on account of (4), 
r E U. In that case the value D(r) + A( = c +A) is recorded in w(i: 0 s i < q) by 
increasing q by 1. 
We have now assembled all ingredients of the program text: 
S: I[ A, B: int 
: I[ i: int 
; i, B := 0,O 
;doi#N+i,B:=i+l,B+d(i)od 
; A:= B/k 
II 
; I[ 4, c, r, p: in? 
; w( i: 0 S i < N): array of int 
; q, c:=o,o 
;doc<A+w:(q)=c+A;q,c:=q+l,c+d(q)od 
;r,p:=q,o{PoAP1AP2} 
;dor# N 
+ w:(q)=c+A{(Ei:psicq: w(i)>c)} 
;do w(p)<c+p:=p+l od{w(p)sc} 
;ifw(p)=c+p,q:=p+l,q+l 
II w(p)> c+skip 
fi {PO:+, A P1 :+I) 
; r, c:= r+l, c+d(r) {POA Pl APL?} 
od 
;b:=(w(q-l)>B) 
Small programming exercises 209 
Since the total number of steps of the inner repetition is at most N, our solution 
has a time complexity that is linear in N. 
In the code above we may, because of P2, replace by c the B in the assignment 
to b. Then B plays a role in the computation of A only. We have not done so, since 
the code above allows the following strengthening of the guard of the outer repetition. 
Since array w is increasing, we know that b may be assigned the value true as soon 
as w(9 - 1) 2 B. Also, if p = 9 we know, because of (4), that for all j E U the values 
O(j) +A have been recorded. We may, consequently, replace the guard r f: N by 
the stronger condition 
Solution of Exercise 8 (touring robot) 
It is requested to determine the number of complete turns made by a robot which 
is moved along the points (X(i), Y(i)) for i = 0, 1, . . . , N - I, 0 and which is turned 
in each of these points counterclockwise to direct it to the next point: 
I[ N: int (Ns2) 
; X, Y( i: 0s i < N): array of int 
{(Ai:O<i<N:X(i)#X((i+l)modN) 
v Y(i) # Y((i + 1) mod N))} 
; I[ c: int 
;s 
{c = “the number of complete turns of the robot”} 
II 
II 
The number of complete turns of the robot equals the number of times the direction 
of the robot is turned to or across the positive X-axis. The latter number is not 
affected if we assume that the robot is initially facing the direction of the positive 
X-axis. Then the robot is turned N + 1 times: twice in point 0 and once in every 
other point. Let, for 0~ is N + 1, T(i) denote the number of times the direction of 
the robot is turned to or across the positive X-axis during the first i turns. The 
postcondition of the functional specification may then be formulated as 
c= T(N+l). 
We choose as our invariant 
PO: c= T(i)AOQis N+l. 
Variables i and c may then be initialized by i, c := 0,O. The guard of the repetition 
is i # N + 1 and the bound function is N - i. 
Directions in the plane can, of course, be represented by (X, Y)-vectors. However, 
in order to simplify the determination whether during a turn the positive X-axis is 
crossed, we choose a representation in which each direction is reduced to the first 
210 , M. Rem 
quadrant X > 0 A Y 3 0. A vector (x, y) is reduced to a triple (b0, b I, q), b0 > 0 A b 1 5 
OA 0~ q s 3, by rotating it clockwise over multiples of 90” until it is in the first 
quadrant. The angle of rotation is q-90” and (b0, bl) is the resulting vector in the 
first quadrant. This conversion may be coded as follows. 
b0, bl, q:= x,y, 0 
;dobOcOvbl<O-+bO,bl,q:=bl,-bO,q+lod 
A simple calculation shows that if during turn i + 1 (OS is N) the direction of 
the robot is changed counterclockwise from (a0, a 1, p) to (b0, bl, q), the positive 
X-axis is turned to or crossed over if and only if 
This is the condition that T(i + 1) = T(i) + 1. Otherwise T(i + 1) = T(i). 
In order not to compute every direction of the robot twice, the invariant is extended 
with 
PI: (~0, a 1, p) = the direction after i turns. 
Recalling that we initially position the robot facing the positive X-axis, Pl may be 
established by a0, a 1, p := 1, 0, 0. 
Thus, our solution becomes 
s: I[ i, a0, ul,p: int 
; i, c := 0,o {PO} 
;UO,Ul,p:=1,0,O{POAP1} 
;doi#N+l 
+ I[ b0, bl, q: int 
;bO,bl,q:=X((i+l)modN)-X(imodN) 
, Y((i+l)mod N)- Y(imod N) 
,O 
;dobO~Ovb1<O+bO,b1,q:=b1,-bO,q+1od 
{ (b0, b 1, q) = the direction after i + 1 turns} 
;ifp>qv(p=qAul* bO>bl *uO)+c:=c+l 
Op<qv(p=qAul * bOSb1 *uO)+skip 
fi {PO;,, A PI} 
; ~0, ul,p:= 60, bl, q {PO;,, A Plj,,} 
II 
;i:=i+l{POhPl} 
od{POhi=N+I,hence,c= T(N+I)} 
II 
Since the inner repetition makes, per step of the outer repetition, at most 3 steps, 
the execution time of the program is linear in N. 


Small programming exercises 5

Science of Computer Programming 5 (1985) 219-229 
North-Holland 
219 
SMALL  PROGRAMMING EXERCISES 7 
M. REM 
Department ofMathematics and Computing Science, Eindhoven University of Technology, 5600 MB 
Eindhoven, The Netherlands 
We have a rather mixed set of exercises this time. The first one, Exercise 17, is a 
graph problem. We are requested to partition a tree into as many smaller trees as 
possible, given a lower bound for the sizes of these trees. It allows a solution whose 
computation time is linear in the number of vertices. 
Exercise 18 deals with mixed binary representations of numbers, i.e. binary 
representations in which negative coefficients are allowed. The problem is to find 
a minimal such representation for a given (possibly negative) integer value N. I 
owe this exercise to J. Misra, who used it as a "Do'nut Hour Puzzle" at the University 
of Texas in 1976. It has an O(log(abs(N))) solution. 
The last exercise is about segments of arrays. A segment is called recurring if 
there exists another segment in the array with the same sequence of values. The 
problem is to determine the length of a longest recurring segment. The solution I
have in mind has a computation time that is quadratic in the size of the array given. 
Exercises 17 and 19 were used in written examinations atthe Eindhoven University 
of Technology in 1982 and 1981. They were concocted by W.H.J. Feijen. 
Exercise 17: chopping trees 
Consider a tree of N (N>~ 1) vertices, i.e. an undirected connected graph of N 
vertices and N-1  edges. Each vertex i, 0<~ i< N, has a nonnegative weight w(i). 
The weight of a tree is the sum of the weights of its vertices. The tree is recorded 
in an integer array v(i: 1 <~ i< N): v(i) is the neighbour of vertex i on the path 
between i and vertex 0. The weight of the tree is at least B, where B is a given 
nonnegative constant. 
By deleting k edges the tree is transformed into k + 1 trees. We are requested to 
compute the maximum number of edges that can be deleted from the tree under 
the restriction that the weight of each resulting tree is at least B. 
Find a statement list S such that 
[[N, B: int;{N>~ 1ABe>0} 
v(i: 1<~ i< N),  w(i: 0<~ i< N): array of int; 
{(Ai: 0<~ i< N: w(i)>lO) ^  B<~(Si: 0~ < i<  N: w(i))} 
I[m: int; 
0167-6423/85/$3.30/ © 1985, Elsevier Science Publishers B.V. (North-Holland) 
220 M. Rem 
S 
{m = (maximum number of edges that can be deleted such 
that the weight of each tree is at least B)} 
]1 
]1 
Exercise 18: minimal mixed binary representation 
A sequence r(i: 0<~ i < m), m >I O, of integer values satisfying 
(Si: 0~ < i<  m: r(i) • 2 i) = N 
is called a mixed binary representation (MBR) of N. It is a minimal MBR if 
m>l l~r (m-  1)#0 and 
(Si: 0<~ i< m: abs(r(i)))<~ (Si: 0<~ i< 1: abs(q(i))) 
for each sequence q(i: 0<~ i < l) that is an MBR of N. For N ¢ 0 we can show 
2 m-1 < 2. abs(N) 
for each sequence r(i: 0<~ i< m) that is a minimal MBR of N. 
Find a statement list S such that 
[[N, M: int; {M~>0A2 M I>2" abs(N)} 
[[m: int; 
r( i: 0<~ i< M): array of int; 
S 
{r(i: 0~ < i<  m) is a minimal MBR of N} 
]1 
]t 
Exercise 19: longest recurring segment 
With RS(p, q) denoting 
(Ed: 0<d<~p:  (Ak: p<~k <q: X(k -d )=X(k) ) )  
we are requested to find a statement list S such that 
I[N: i n t ;{N~ 1} 
X ( i: O~ i < N): array of int; 
I[m: int; 
S 
{m = (MAX p, q: 1 <~ p <~ q <~ N ^ RS(p, q): q -p )}  
]1 
]1 
Small programming exercises 221 
Solution of Exercise 14 (ascending paths) 
We are requested to find a statement list S such that 
I[N,M,X: int; {N~ I ^M>-O^O<~X <N} 
b(j: O<~j<~ N),  e, d(i: 0<~ i< M): array of int; 
{suc(O, b, e)} 
[[r(j: 0<~j < N): array of bool; 
S 
{Aj: 0<~j < N:  r(j) - (G has an ascending path from X to j))} 
]l 
]1 
The major difference between the solution of this exercise and that of Exercise 
13 is that we have to select a particular grey vertex to be coloured black. As in 
Exercise 13 we partition the vertex set into three (possibly empty) subsets V0, Vl, 
and V2. We maintain as an invariant hat no vertex in V2 has a successor in V0 
and that X ~ V1 u V2. 
Let, for V a set of vertices, RA(V) denote the set of all vertices j for which there 
exists an ascending path from a vertex in V to j. Notice that RA(~)--~. The 
postcondition is then 
(Aj: O<~j < N: r ( j ) - ( j  ~ RA({X}))) 
We maintain P0 as an invariant: 
P0: V2u RA(V1)= RA({X}). 
It may be initialized with Vl = {X} and V2 = 0. Now P0 ^  Vl = 0 implies V2 = 
RA({X}). By also mainfaining 
PI :  (Aj: 0~<j < N:  r(j) =- (j ~ V2)) 
as an invariant, we may conclude the postcondition from P0A P1 A V1 =0. We 
choose V1 # 0 as the guard of the repetition. 
The weight of an ascending path is the maximum of the weights of its arcs. Hence, 
the weight of an ascending path that consists of just one vertex is - in f  and that of 
a longer path is the weight of its last arc. An ascending path of which the last vertex 
is in V1 and of which all other vertices are in V2 is called a black path. 
We introduce an integer array q(j: 0 <~j < N) in which we record, observing the 
following invariant, one value for each j ~ V1 w V2: 
P2: (Aj: j ~ Vl: q(j) -- (minimum of the weights of the 
black paths from X to j))  
^ (Aj: j e V2: q(j) = (minimum of the weights of all 
ascending paths from X to j))  
P2 can be initialized by q: (X)=- inf .  
222 M. Rein 
At each step of the repetition one vertex is moved from V1 to V2. We now come 
to the selection of such a vertex. Consider a vertex j satisfying 
q( j )=(MINk:  k~ Vl: q(k)). 
Since X ~ V1 u V2, and since no vertex in V2 has a successor in V0, any ascending 
path from X to j has an initial part that is a black path. Therefore, the weight of 
each ascending path from X to j is at least 
(MINk:  k~ VI: q(k)) 
Since we know that there exists a black path--and,  hence, an ascending path-- f rom 
X to j of the above weight, we may conclude that q(j) is the minimum of the 
weights of all ascending paths from X to j. We select j and move it to V2 without 
changing q(j). This establishes a new black path to each successor e(i) ~ VOu V1 
of vertex j for which q(j) <~ d(i). The weight of this new black path is d(i). 
We have now assembled all ingredients of the program. Sets V0, V1, and V2 are 
recorded as in Exercise 13. The selection of vertex j ~ V l - -and  its deletion from 
vl ( j :  0<~j< nv l )mmay be coded as follows: 
DEL" j :=  0 
;do j+  1 ~ nvl 
-~ if q(vl( j ))<~q(vl( j+ 1))~ vl:swap(.~j+ 1) 
[3 q(v l ( j ) )~ q(v l ( j+ 1)) ~ skip 
fi 
; j := j+ 1 
od {(Ak: 0<~ k < nvl: q(vl(k))>i q(vl(nvl  - 1)))} 
; j :=  v l (nv l -  I); nvl := nv l -1  
The insertion of a vertex k into v l ( j :  0<~j< nvl) is then, as in Exercise 13, simply 
achieved by 
INS: v l : (nv l )=k;nv l :=nv l+ l  
Thus we obtain the following solution: 
S: I[nvl: int ; 
v, v l ,  q( j :  0~<j< N): array of int; 
I[J: int; j := 0 
;do j#  N~ v : ( j )=0;  r:( j)  =false; j :=j+ 1 od 
]1 
; v : (X )= 1 
; nvl := 1; vl:(0) = X 
; q : (X)=- in f  
; do nv 1 ~ 0 
I[J: int; 
Small programming exercises 223 
DEL  
; v:( j)  = 2; r : ( j )=  true 
;1[i: int; i :=b( j )  
; do i#  b ( j+  1) 
-~  i f  q(j)<~d(i) 
--> Ilk: int; k:= e(i) 
; i f  v(k) = 0-~ v : (k )  = 1; q: (k )  = d( i ) ;  INS 
D v(k) = 1 -> q : (k )  = q(k)  rain d(i) 
D v(k)  = 2--> sk ip 
fi 
]1 
71 q(j)  > d (i) 
-~ sk ip  
fi 
; i:= i+1 
od 
]1 
]1 
od 
]1 
As in all our solutions of graph problems, the inner repetition makes, over the 
whole computation, at most M steps. The computation time of OEL is, however, 
O(N).  Since DEE Occurs within a repetition that makes at most N steps, and since 
M < N 2, the computation time of our solution is O(N2). 
One could argue that the introduction of array v 1 has not been very effective in 
reducing the time to select vertex j. We can indeed obtain a quadratic solution 
without using array vl. DEL and INS can then be coded as follows: 
DEL: I[g, m: int 
;dog#N 
i f  v(g) 
13 v(g) 
fi 
; g :=g+l  
od 
]l {v ( j )=  1 ^  (Ak: 0<~ k< N^ v(k )= 1: q(k)>~ q(j))} 
; nvl := nv l -1  
INS: nv l := nv l + 1 
;g,m:=O, inf 
= 1 -~ i f  q(g) <~ rn ~ j ,  m := g, q(g) 13 q(g) >I m -~ skip fi 
# 1 -~ sk ip  
By representing set V1 as a heap the computation times of INS and DEL can be 
made O(log(N)) .  The computation time of the solution then becomes O( (N+ 
M) • log(N)) ,  which is, except for very dense graphs, better than O(N2). We say 
224 M. Rein 
that v l ( j :  0~<j< nvl) is a heap if 
(Aj: 1 ~<j < nvl: q (v l ( ( j -  l) div 2) )4  q(vl( j ) ) ) .  
Our initialization makes v l ( j :  0<~j< nvl) into a heap. In order that it remains a 
heap INS and DEL have to be recoded. Since heaps and heapsort are well-covered 
by the general computing literature, we just give the invariants and codes. For the 
formulation of the invariants we first need to define two sets ANC(j) and DESC(j) 
for each j I> 0: 
ANC(O) = {0}, 
ANC( j )={j}•ANC(( j - -1)d iv2)  fo r j~  >1,  
DESC(j) =0  fo r j~  > nvl,  
DESC( j )  = {j} u DESC(2  • j + 1 ) u DESC(2 • j + 2) 
The invariant of INS is 
forO<~j< nvl. 
(Ai, j :  i~ANC(j)  ^ 0<~j< nvl ^ j  # h: q(v l (  i))<~ q(v l ( j ) ) )  
^ g= (h -  1) div2A h< nvl 
It may be coded as follows: 
INS: vl : (nvl )  = k; nvl := nvl + 1 
;l[g, h: int;g, h:=(nvl  -2 )  div 2, nv l - I  
;do g ~> 0 cand q(vl(g)) > q(vl (h)) 
-> vl: swap(g ,h ) ;g ,h :=(g-1)d iv2 ,  g 
od {vl( j :  0~<j< nvl) is a heap} 
]1 
DEL is slightly more complicated. Its invariant is 
(Ai, j :  0~ < i<  nvl A i#  g ^  j ~ DESC( i): q(v l (  i))<<- q(v l ( j ) ) )  
A g=(h-  1) div2A h>~ 1 
A (h =2"  g+2)=-'(2" g+2< nvl  ^  q(vl(2" g+ 1))>i q(v l (2-  g+2)) )  
A (h =2"  g+ 1)-- (2" g+2~ > nvl v q(vl(2 • g+ 1))~ < q(vl(2 • g+2)) )  
The code we suggest for DEL is 
DEL" j := vl(0); nvl := nvl - 1 ; vl: swap(O, nvl) 
; I[g, h: int; g := 0 
; if 2 < nvl cand q(vl(1)) I> q(vl  (2)) -> h := 2 
[3 2 >> - nvl cot q(vl(1))<~ q(vl(2))--> h := 1 
fi 
;do h < nvl e.and q(v l (g) )> q(v l (h))  
--> vl: swap(g, h); g, h:= h, 2*h+2 
; if h < nvl cud  q(v l (h -  1))>I q(vl(h))-->skip 
[3 h >>- nvl cor q(v l (h  - 1)) <~ q(vl(h))  --> h := h - 1 
Small programming exercises 225 
fi 
od (v l ( j :  0<j< nvl) is a heap} 
31 
Notice that both for INs and DEL the number of steps of the repetition is log2(nvl). 
Solution of Exercise 15 (the tunnels) 
We have to find a statement list S such that 
][N, M, X, Y: int; {N~ > 1A M~>0A0~<X< NA0~ < Y< N} 
b(j: O<~j<~ N), e, d(i: 0<~ i< M): array of int; 
{suc(G, b, e) A G strongly connected A (Ai: 0~ < i < M: d(i) I> 1 )} 
][z: int; 
S 
{z--(maximum of the weights of the paths from X to Y)} 
II 
]1 
in which the weight of a path is the minimum of the weights of its arcs. The weight 
of a path consisting of a single vertex is, consequently, inf. 
This exercise is very similar to Exercise 14: again a particular grey vertex should 
be selected, and again all three possible ways explained in the discussion of Exercise 
14 may be applied. We present a solution wthout array v 1. Our invariant is this time 
P: (Aj: j ~ VI: q(j) = (maximum of the weightsof the 
black paths from X to j))  
A (Aj: j e V2: q(j) = (maximum of the weights of all 
paths from X to j))  
in which a black path is a path of which the last vertex is in V1 and of which all 
other vertices are in V2. Now the vertex j e V1 that is moved to V2 satisfies 
q(j)=(MAXk: ke VI: q(k)) 
Moving j to V2 establishes a new black path to each successor e(i)~ VOw V1 of 
vertex j. It has weight q(j) miu d(i). 
Since G is strongly connected, there is a path from X to Y. Therefore, the 
computation will eventually move Y to set V2. From P ^ Y e V2 we may conclude 
that q(Y) is the maximum of the weights of the paths from X to Y, i.e. that q(Y) 
is the value to be assigned to z. We choose Y ~ V2 as the guard of the repetition. 
S: [[v, q(j: 0~j< N): array of int; 
I[J: int; j := 0 
;do /# N~ v : ( j )=0; j := j+ 1 od 
]l 
; v:(X) = 1; q:(X) = inf 
226 M. Rein 
;do v(Y)  ¢2  
-~ I[J: int; 
Jig, m: int; g, m:=0,  - in f  
;dog~ N 
-~ if v(g) = 1 ~ if q(g) >i m ~j ,  m := g, q(g) I-1 q(g) <~ m ~ skip fi 
od 
]1 { v(j)  
," v : ( j )=  
;1[i: int; 
;do i¢  
..-> 
od 
]1 
]1 
od 
; z := q( Y) 
]1 
[3 v(g) ~ 1 ~ skip 
fi 
g:=g+l  
= 1 ^ (Ak :  O<~k<NA v(k )= 1: q(k)~q( j ) )}  
2 
i := b(j) 
b( j+ l )  
Ilk: int; k:= e(i) 
; if v(k) =0-> v:(k) = 1; q:(k) = q(j) min d(i) 
[] v (k )= 1 --> q:(k) = q(k) max (q(j) min d(i)) 
D v(k) = 2--> skip 
fi 
]1 
i := i+1 
Solution of Exercise 16 (two-person game) 
Directed graph G represents the positions and moves of a two-person game. A 
player who cannot move loses. We are requested to determine for each position of 
the game whether it is won, lost, or undecided: 
[[N, M:  int; {N~ > 1 ^  M~>0} 
b(j: O~ j ~ N) ,  e( i: 0 < - i<M) :  array of int ; 
{PRED(G, b, e)} 
[[q(j: 0 <~j < N) :  array of int; 
S 
{(Aj: 0<~j < N:  (q(j)  = -1) -  (vertex j is lost) 
^ (q(j) = 0) =- (vertexj  is undecided) 
^ (q(j)  = 1) -- (vertexj  is won))} 
]1 
]1 
Small programming exercises 227 
Among the graph problems we have solved thus far, the solution of this exercise 
resembles most that of Exercise 11. 
We use SG, $, and P with the same meaning as in the solution of Exercise 11. 
Let w(G), l(G), and u(G) denote the sets of won vertices of (3, lost vertices, and 
undecided vertices respectively. If S(j) ~ 0 for each vertexj of G, then any (s, t)-path 
in G is infinite. In that case all vertices of G are undecided. 
Next assume that S(j)--0 for vertex j. The only (s, t)-path from j is then the 
path---of length 0mconsisting of vertex j only. Since the length of this path is even, 
vertex j is lost. Consider a strategy s with s(k) =j for all k ~ P(j). For each strategy 
t the (s, t)-paths from a vertex in P(j) then consist of just one arc: the arc to vertex 
j. Since these paths have odd lengths, all vertices in P(j) are won. To summarize, 
vertices without successors are lost and all their predecessors are won. 
Let G' denote the subgraph of G induced by the other vertices than j or its 
predecessors, with j still satisfying S(j)= 0. We prove 
l( G') u {j} = l( G) and w(G')uP(j)=w(G). (l) 
It is easy to see that the definitions of won and lost are not affected if we restrict 
the strategies  and t in them to strategies that map each vertex of P(j) onto j. For 
such strategies we have for each vertex k of G' that the (s, t)-path from k in G 
either equals the one in G' or is the one in G'  extended with a vertex from P(j) 
followed by vertex j. Since.in the definitions of won and lost only the parity (odd 
or even) of the lengths of the (s, t)-paths plays a role, this proves (1). 
Property (1) strongly suggests an invariant of the following form: 
w(SG(V) )  u W = w(G)  
^ I(SG( V) )u  L=I (G)  
^ u(SG(V) )  = u(G). 
(2) 
This can be initialized by making V equal to the set of vertices of G and W = L = 0. 
According to (1), we can shrink set V if S(j, V)= 0 by 
V, W,L:= V\({j}uP(j, V)), W~P( j ,  V),L~2{j} 
From the above assignment we see why it is convenient hat in this exercise the 
graph is given by its predecessor relation: for each vertex in V we are interested in 
the number of successors and in the identities of the predecessors. 
If for all j ~ V we have S(j, V) ~ 0 relation (2) simplifies to 
W = w(G)  ^ L = I(G) ^ V= u(G). 
As in Exercise 11, we split V into two sets V0 and V1, in which V1 consists of 
those vertices that have no successors in SG(V). Thus our invariant becomes P0 ^  P I :  
PO: w(SG(VOu V1))u W= w(G) 
^ I (SG(VOuV1))uL= I(G) 
^ u(SG(VOu Vl)) = u(G), 
228 M. Rem 
PI: (Aj : jE VO: S(.~ VOw3 Vl) #0) 
A (Aj : jE VI: S(j,  VOu V1)=0). 
Our program will have the following structure: 
VO, V1 := {j[ S ( j )¢  0}, {Jl S(j) =0} 
; W, L:=0, O 
;do V1 ~0 
letj  ~ V1 
; L, V1 := Lu{ j} ,  VI\{j} 
; for each k ~ P( j )  c~ VO 
(W, VO:= Ww{k},  VO\{k} 
; for each h ~ P( k ) 
if S(h, VOw V1)=0~ V0, V1 := V0\{h}, V1 u(h} 
D S(h, VOu V1) #0~sk ip  
fi 
) 
od 
; U:= V0 
For expressing the guards in the selection above, we introduce an integer array 
t(j: 0 <~j < N)  and maintain 
(Ak: k~ VOu VI: t(k)=lS(£ vou Vl)[). 
The postcondition suggests the following way to record VOw V1, W, and L: 
(Aj: 0<~j< N: (q ( j )=-1) -= (jE L) 
^(q( j )=O) - ( j6  VOw V1) 
^ (q( j)  = 1 ) = (j ~ W)). 
We present V1 in the usual way by two variables v 1 and nvl. 
The initialization of t, q, vl, and nvl may be coded as follows: 
IN IT :  I[J, i: int; 
j :=O;do j# N--) t: (j) =0; q: (j) =O; j := j+ 1 od 
; i := O; do i ¢ M --> t:(e(i)) = t(e(i)) + 1 ; i := i + 1 od 
;j, nvl  :=O, O 
;do j¢  N 
--> id t( j)  =0-> vl: (nvl) =j;  nvl  := nvl + 1 
[] t( j)  1> 1 ---> skip 
fi 
; j := j+ l  
od 
31 
Small programming exercises 229 
Our solution is then 
S: l[nvl: int; 
vl, t(j: 0<~j< N):  array of int; 
IN IT  
; do nv 1 ~ 0 
-> I[J, i: int; 
j:= v l (nv l -1 ) ;  nvl := nv l -1 ;  q: ( j )=-1  
; i:= b(j) 
; do i#  b( j+ 1) 
-* Ilk: int; k:= e(i) 
; i f  q(k) =0 
--> q : (k )= 1 
; I[g: int; g:-- b(k) 
; do g # b(k+ l) 
--> I[h: int; h:= e(g); t:(h) = t (h ) -  1 
; i f  t(h) =0--) vl:(nvl)  = h; nvl := nvl + 1 
[3 t(h) i> 1 -> skip 
fi 
]1 
g:=g+l  
od 
]1 
[3 q (k )= 1 
skip 
fi 
]1 
; i := i+1 
od 
]1 
od 
]1 
The innermost repetition makes one step for each arc leading to a won position; 
the middle repetition makes one step for each arc to a lost position. So, although 
we have a triple repetition, the computation time is still l inear in the number of 
vertices and arcs of G. 


Small programming exercises 7 

Science of Computer Programming 4 (1984) 87-94 
North-Holland 
87 
SMALL PROGRAMMING EXERCISES 3 
M. REM 
Depanment of Marhemarics and Computing Science, Eindhoven University of Technology. 5600 
MB, Eindhooen, the Nerherlands 
Some programming problems seem simple until one actually tries to code them. 
Then one easily gets lost in details and seemingly exceptional boundary cases. The 
‘touring robot’ (Exercise 8) is an example of such a problem. Both new exercises 
were used in written examinations for the “Introduction to the art of programming” 
lectures at Eindhoven University of Technology. They turned out to be more difficult 
than we had expected. Exercise 7 was given in 1979 and Exercise 8 in 1976. 
The specifications of the exercises contain the operator mod. Roughly speaking, 
it expresses the remainder after division. More precisely, let X and Y be integer 
values with Y Z 0. Then 
Xdiv Y=qhXmod Y=r 
is equivalent to 
x=q* Y+rAOsr<abs(Y). 
In Exercise 8 a sequence of points in the plane is given. One of the potential 
complications of this exercise is the possibility that consecutive points are on a line 
parallel to the X- or Y-axis or that three consecutive points are on one line, and 
one of the aims of the exercise is to avoid any complications these or other ingredients 
may present. Both exercises allow linear solutions. None of the solutions may involve 
real arithmetic, i.e. all expressions must be of type integer or boolean. My solution 
of Exercise 7 involves the introduction of at least one auxiliary array. (For an 
exposition on the notation used the reader is referred to Small Programming 
Exercises 1, Sci. Compuf. Programming 3 (1983) 2 17-222.) 
Exercise 7: regular polygon on a circle 
N points are located on a circle and clockwise numbered 0, 1, . . . , N - 1. The 
arc between points i and (i+ 1) mod N has length d(i). The circumference of the 
circle is, consequently, (Si: 0 s i < N: d(i)). It is requested to determine whether, 
for given k, there exist, among the points given, k points that are the vertices of a 
regular k-gon: 
[k, N: int (3 d k s N} 
;d(i:O~i<N):arrayofint 
0167-6423/84/53.00 @ 1984, Elsevier Science Publishers B.V. (North-Holland) 
88 M. Rem 
{(Ai:O~i<N:d(i)21)h(Si:O<i<N:d(i))modk=O} 
; j[b: boo1 
;S 
{b = “among the N points given there exist k points 
that form a regular k-gon”) 
II 
II 
Exercise 8: touring robot 
Given are N points, numbered 0, 1, . . . ,N-l,intheplane.Thepair(X(i), Y(i)), 
0 s i C IV, represents the Cartesian coordinates of point i. A robot moves from point 
0, via all points given, back to point 0, observing the following rules. 
(i) the robot starts in point 0 facing point 1; 
(ii) the robot moves in the direction it faces; 
(iii) arriving in point i, 0 s i < IV, the robot turns counterclockwise over an angle 
LL satisying 0” s (Y < 360” until it faces point (i + 1) mod N; 
(iv) the robot ends in point 0 facing point 1. 
As a result of its tour around the points the robot has completed an integral number 
of turns. It is requested to determine this number: 
I[N: int {N B 2) 
;X, Y(i:OSi<N):arrayofint 
{(Ai:Osi<N:X(i)ZX((i+l)modN) 
v Y(i)# Y((i+l)modN))} 
; I[ c: int 
;S 
{c = “the number of turns of the robot”} 
II 
II 
Solution of Exercise 3 (coincidence count) 
It was requested to find a statement list S such that 
I[M,N: int{M~OAN~O} 
;F(i:O~i<M),G(j:O~j<N):arrayofint 
{F and G are increasing} 
Small programming exercises 89 
; I[ c: in? 
;s 
{c=(Ni,j:O~iikf~O~j<N:F(i)=G(j))} 
II 
II 
Define, for O~~~MMOO~~N, 
C(m,n)=(Ni,j:m~i<M~n~j<N:F(i)=G(j)). 
The postcondition may then be formulated as 
c = C(O,O). 
We introduce two variables, m and n, and we propose to keep the following assertion 
invariant. 
P: c+C(m,n)=C(O,O)hO~rn~~~h~~~N 
The repetition may then be initialized by “m, n, c:= 0, 0,O". A suitable bound 
function is M - m + N - n. Since c( M, n) = c( m, N) = 0, we have 
Ph(m=kfvn=N) a c=C(O,O) 
This leads to the choice of m # M A n # N as the guard of the repetition. 
As usual, we consider the first conjunct of Pl+l, i.e. 
c+C(m+l,n)=C(O,O) 
or 
c+C(m,n)-(Nj: nsj<N:F(m)=G(j))=C(O,O). 
Since G is increasing, we have 
(Aj: n<j<N: G(n)<G(j)) 
and, hence, 
(Nj: n sj<N: F(m) = G(j)) = 
0 if F(m)< G(n), 
1 if Ftm) _ G(n) 
We thus have 
{Phm#~An#Nh~(m)~G(~)}m:=m+1{P} 
and 
{PI\m#~hn#NI\~(m)=G(n)}C,m:=C+l,~+1{P}. 
90 M. Rem 
Exploiting the symmetry of the problem, we arrive at the following solution: 
s: IC m, n: inf 
; c, M, n := o,o, 0 {P} 
;domfMhn#N 
+ifF(m)<G(n)+m:=m+l 
lJF(m)=G(n)+c,m:=c+l,m+l 
OG(n)<F(m)+n:=n+l 
OG(n)=F(m)+c,n:=c+l,n+l 
od {PA (m = M v n = N) and, hence, c = C(0, 0)) 
II 
If so desired, the two guarded commands with equal guards may be combined into 
“F(m)=G(n)+c,m,n:=c+l,m+1,n+1”. 
The problem we have just tackled may be looked upon as a two-dimensional 
one: we were interested in the number of pairs (i,j) satisfying a certain condition. 
This led to the introduction of two variables. We did not, however, find the invariant 
for these variables by just replacing in the postcondition two constants by two 
variables. Such an approach would have led to an invariant of the form 
P’: c=(Ni,j:Osi<m,tOsj<n:F(i)=G(j)) 
AO~m<MhOdn~N. 
We would like to conclude from the conjunction of the invariant and m = M A n = N 
that the postcondition holds. But P’ by itself is then not sufficient. For such a 
conclusion to be valid, we need to extend P’ with the following assertion Q: 
Q: F(m-l)<G(n)~G(n-l)<F(m). 
In order that Q be defined for 0 s m ~M~Osnn4, the domains of F and G 
must be extended in, for example, the following way: 
F(-1) = G(-1) = -inf, 
F(M) = G(N) = inf 
in which inf is the identity element of the operator min. (The identity element of 
max is -inf ) 
As the reader may have noticed, our ‘standard invariant’ is becoming rather 
complicated. That is why we have chosen the approach presented earlier. The 
striking difference between the invariants P’ and P is that in P’ the computed-and 
Small programming exercises 91 
assigned to c-part of the requested answer C(O,O) is (in form) similar to that 
answer, and that in P the part still to be computed-C(m, n)-is similar to the 
answer. I learned the solution strategy presented, which will be used in the other 
three solutions as well, from Jan L.A. van de Snepscheut and W.H.J. Feijen. Readers 
familiar with the saddleback search may notice its similarity to our solution S. 
Solution of Exercise 4 (dominance count) 
We have to find a statement list S such that 
J[M,N: int(MBOhN30) 
; F(i: 0~ i<M), G(j: Osj<N): array of int 
{F and G are ascending} 
; Ic c: int 
;s 
{c=(Ni,j: Osi<MnOsj<ZV: F(i)> G(j))} 
II 
II 
Define, for OSrnSMhO~n<N, 
C(m,n)=(Ni,j: msi<MAnSj<N:F(i)>G(j)). 
The postcondition, the invariant P, the initialization, the bound function, and the 
guard are equal to those in Exercise 3. In this case the difference between C(m, n) 
and C(m+l, n) is 
(Nj: n~j<N: F(m)> G(j)). 
Since G is ascending, the term is 0 if F(m) 6 G(n). The problem is not symmetric 
in F and G and, therefore, we have to consider C( m, n + 1) as well. The difference 
between C( m, n) and C( m, n + 1) is 
(Ni: msi<M: F(i)> G(n)). 
Since F is ascending, the term above equals M - m if F(m) > G(n). We obtain the 
following solution: 
s: I[ m, n: int 
; c, m, n := O,O, 0 {P} 
;dom#MAn#N 
+ifF(m)<G(n)+m:=m+l 
92 M. Rem 
OF(m)>G(n)-,c,n:=c+M-m,n+l 
fi W) 
od {PA (m = M v n = N) and, hence, c = C(0, 0)) 
II 
Solution of Exercise 5 (head to tail sums) 
In this exercise we have to find a statement list S such that 
I[N: int {N 2 0) 
; F(i: 0s i<N): array of int{(Ai: 0~ i<N: F(i)>O)} 
; I[ c: int 
;S 
{c=(Nj,k:O~j=zNhO~k~N:H(j)=T(k))} 
II 
II 
in which, for OsjsN~Oa k<N, 
H(j)=(Si: O<i<j: F(i)), 
T(k) = (Si: k G i < N: F(i)). 
Notice that H(0) = T(N) = 0 and H(N) = T(0). 
The exercise is very similar to the coincidence count, except that we have two 
functions of which one (H) is increasing and the other (T) decreasing. In the 
coincidence count we obtained C(m, n) from the postcondition by replacing the 
lower bounds of the domains of the two functions by variables. This time we replace 
by a variable the lower bound (0) of the domain of H and the upper bound (N) 
of the domain of T, i.e. we define 
C(m,n)=(Nj,k:m~jiN~OOkkn:H(j)=T(k)). 
The postcondition is then, of course, 
c = C(0, N) 
and the invariant 
P: c+C(m,n)=C(O,N)hO~m~NhO~n4N. 
The repetition is initialized by “m, n, c := 0, N, 0”. The bound function is N - m + n. 
Small programming exercises 93 
Since 
c(N, n) = (Nk: OS k s n: H(N) = 7-(k)) 
=(Nk:Osksn: T(O)=T(k)) 
= 1, 
and, likewise, c( m, 0) = 1, we have 
Ph(m=Nvn=O) * (c+l=C(O,N)) 
We, therefore, choose m # N A n # 0 as the guard of the repetition. 
By considering the first conjuncts of Pz+i and Pz_i we obtain along the same 
lines as in Exercise 3 a program that contains an alternative command in which 
H(m) and T(n) occur in the guards. In order to be able to express these guards 
we extend the invariant P to PA Q. 
Q: h=H(m)ht=T(n). 
Noticing that H(m+l)=H(m)+F(m) and that T(n-l)=T(n)+F(n-l), we 
are led to the following solution: 
S: [[m, n, h, t: int 
;m,n,c:=O,N,O{P} 
; h, t:=O,O{PI\ Q} 
;dom#Nhn#O 
+ifh<t*h,m:=h+F(m),m+l 
Oh=t+c,h,m:=c+l,h+F(m),m+l 
Ot<h+t,n:=t+F(n-l),n-1 
llt=h+c,t,n:=c+l,t+F(n-l),n-1 
fi{PA Q) 
od{PhQh(m=Nvn=O), hence, c+l=C(O,N)} 
;c:=c+l{c=C(O,N)} 
II 
Solution of Exercise 6 (minimal distance) 
It is requested to find a statement list S such that 
I[M,N: int{&fdlhNZl} 
;F(i:O<i<M),G(j:Oaj<N):arrayofint 
94 M. Rem 
{F and G are ascending} 
; Ir a: int 
;s 
{a=(MINi,j:O~i<M~OsjcN:abs(F(i)-G(j)))} 
II 
II 
By this time the reader will probably have mastered our solution strategy. With 
C(m,n)=(MINi,j:m~i<M~n~j<N: abs(F(i)-G(j))) 
the invariant is 
P: aminC(m,n)=C(O,O)hO~mdMhO~n~Ar. 
Notice that for m = A4 v n = N the formula C(m, n) concerns the minimum of the 
empty set. This is, by definition, inf, the identity element of the operator min.(The 
maximum of the empty set is -inf) Thus, C(M, n) = C(m, N) = inf Since 
C(m,n)=C(m,n+l)min(MINi:m~i<M:abs(F(i)-G(n))) 
and since F is increasing, we have that if F(m) 3 G(n) 
C(m,n)=C(m,n+l)min(F(m)-G(n)). 
Exploiting the symmetry in F and G, we obtain the following solution: 
s: I[m, n, a := 0, 0, inf {P} 
;dom#MAn#N 
+ifF(m)~G(n)+a,n:=amin(F(m)-G(n)),n+l 
C!G(n)~F(m)+a,m:=amin(G(n)-F(m)),m+l 
fi {PI 
od{Ph(m=Mvn=N), hence, a=amininf=C(O,O)} 
II 


Small programming exercises 7

Abstract

Similar works

Full text

Available Versions

Elsevier - Publisher Connector

Elsevier - Publisher Connector

NARCIS

Elsevier - Publisher Connector

Elsevier - Publisher Connector

NARCIS

Elsevier - Publisher Connector

Elsevier - Publisher Connector

Elsevier - Publisher Connector

Elsevier - Publisher Connector