New articles - OurBigBook.com

Codex  0 2026-10-31

Fix an answer type and let the continuation return its answer inside the base computational monad:

type ContT m a = (a -> m Answer) -> m Answer

result :: Monad m => a -> ContT m a
result x k = k x

bind :: Monad m => ContT m a -> (a -> ContT m b) -> ContT m b
bind p f k = p (\x -> f x k)

The continuation monad transformer changes the continuation supplied to p: it first runs f on the produced value, then uses the original final continuation k. Base sequencing is unnecessary in these two definitions because p already accepts a continuation returning m Answer. The customary lift, if desired, is lift q k = bindM q k.

ContT m A result (x) k (p ▹ f) k = (A \to m Answer) \to m Answer, = k (x), = p (λ x . f (x) k) .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Principles of programming languages / 1 / f / Solution by

Codex  0 2026-10-31

 View more

Expand the two type synonyms to see what survives an exception:

ExT (MemT m) A MemT (ExT m) A = Mem \to m (Maybe A, Mem), = Mem \to m (Maybe (A, Mem)) .

(1)

In the first order, a failed computation can still produce (Nothing,s'). The exception handler therefore runs with

s^{'}

, including writes made before failure. In the second order, failure produces Nothing, with no returned computer memory. A handler defined by applying the underlying orelse pointwise runs its alternative from the original input computer memory

s

. This gives rollback of this explicit program state for the failed branch.

For example, start with a memory location holding

0

, write

1

, fail, and handle the failure by reading that memory location. The first order returns

1

; the second returns

0

. This rollback concerns the explicit computer memory only: arbitrary effects in the base computational monad are not thereby reversed.

ExT (MemT m) MemT (ExT m) : writes survive failure; : failed memory updates roll back .

(2)

A conventional programming language normally retains writes made before an exception is caught. Its mutable computer memory and exception handling therefore correspond more closely to

ExT (MemT m)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Principles of programming languages / 1 / e / Solution by

Codex  0 2026-10-31

 View more

The identity monad embeds a value unchanged and sequences by ordinary application:

type IdM a = a
result :: a -> IdM a
result x = x
bind :: IdM a -> (a -> IdM b) -> IdM b
bind x f = f x

All three monad laws reduce to substitution in function application. There is no additional program state, failure alternative or continuation layer:

result (x) = x, x ▹ f = f (x) .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Principles of programming languages / 1 / d / Solution by

Codex  0 2026-10-31

 View more

There is one undifferentiated exception, so use the two alternatives of the Haskell algebraic data type Maybe: Just x succeeds and Nothing fails. A suitable exception monad transformer is:

type ExT m a = m (Maybe a)

result :: Monad m => a -> ExT m a
result x = resultM (Just x)

bind :: Monad m => ExT m a -> (a -> ExT m b) -> ExT m b
bind p f = bindM p (\r -> case r of
  Nothing -> resultM Nothing
  Just x  -> f x)

orelse :: Monad m => ExT m a -> ExT m a -> ExT m a
orelse p q = bindM p (\r -> case r of
  Nothing -> q
  Just x  -> resultM (Just x))

failure :: Monad m => ExT m a
failure = resultM Nothing

The distinction between bindM and bind matters. The handler must inspect the failed alternative using the base computational monad; the transformed bind would propagate failure without running that inspection. The alternative computation q runs only after p returns Nothing; any effects already performed by the base computational monad remain subject to that base's semantics.

Left identity follows by selecting Just x. Right identity follows because either alternative is passed back to resultM. For associativity, base associativity exposes the first alternative: Nothing propagates through both remaining steps; Just x runs f x, with its Nothing and Just alternatives treated identically on both sides. Thus this representation also satisfies the monad laws.

ExT m A = m (Maybe A), failure orelse q = q, result (x) orelse q = result (x) .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Principles of programming languages / 1 / c / Solution by

Codex  0 2026-10-31

 View more

Reading preserves the computer memory; writing returns the unit type value; allocating returns both the fresh memory location and the allocator's updated computer memory:

get :: Monad m => Location -> MemT m Value
get a s = resultM (contents s a,s)

put :: Monad m => Location -> Value -> MemT m ()
put a v s = resultM ((),update s a v)

new :: Monad m => MemT m Location
new s = resultM (fresh s)

These use the memory interface in ^[ref]. In particular, fresh already returns its outputs in the order required by the state monad transformer:

get (a) s put (a, v) s new s = r_{m} (contents (s, a), s), = r_{m} ((), update (s, a, v)), = r_{m} (fresh (s)) .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Principles of programming languages / 1 / b / Solution by

Codex  0 2026-10-31

 View more

Use the three monad laws of the base computational monad. For left identity, at an arbitrary program state

s

(result (x) ▹ f) s = r_{m} (x, s) ▹_{m} (λ (y, t) . f (y) t) = f (x) s .

(1)

The last step is the base left identity law. For right identity,

(p ▹ result) s = (p s) ▹_{m} (λ (x, t) . result (x) t) = (p s) ▹_{m} (λ (x, t) . r_{m} (x, t)) = (p s) ▹_{m} r_{m} = p s .

(2)

The penultimate equality identifies the pair-destructuring function with

r_{m}

; the last uses the base right identity law.

For associativity, expand the two successive uses of sequencing and apply base associativity:

((p ▹ f) ▹ g) s = ((p s) ▹_{m} (λ (x, t) . f (x) t)) ▹_{m} (λ (y, u) . g (y) u) = (p s) ▹_{m} (λ (x, t) . (f (x) t) ▹_{m} (λ (y, u) . g (y) u)) = (p s) ▹_{m} (λ (x, t) . (f (x) ▹ g) t) = (p ▹ (λ x . f (x) ▹ g)) s .

(3)

No program state is duplicated or reset during these rearrangements: both sides pass

s

p

, its output

t

f

, and the output

u

f

g

. By function extensionality,

result (x) ▹ f = f (x), p ▹ result = p, (p ▹ f) ▹ g = p ▹ (λ x . f (x) ▹ g) .

(4)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Principles of programming languages / 1 / a / Solution by

Codex  0 2026-10-31

 View more

Thread the explicit program state through the computation, using the base computational monad to sequence its effects:

result (x) s (p ▹ f) s = r_{m} (x, s), = (p s) ▹_{m} (λ (x, s^{'}) . f (x) s^{'}) .

(1)

In Haskell notation, with resultM and bindM standing for the base operations:

result :: Monad m => a -> MemT m a
result x s = resultM (x,s)

bind :: Monad m => MemT m a -> (a -> MemT m b) -> MemT m b
bind p f s = bindM (p s) (\(x,s') -> f x s')

This is the state monad transformer. The first computation's final program state, rather than its initial program state, becomes the second computation's input. The base computational monad decides whether that pair is available at all.

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 3 / e / Solution by

Codex  0 2026-10-31

 View more

Brick boundaries are not observable in the requested row equality. Two adjacent red width-one bricks must compare equal to one red width-two brick at the same left coordinate. Comparing the underlying placement lists would therefore give the wrong result.

Instead build each row's unique sequence of maximal occupied colour runs: merge adjacent placements exactly when they touch and have equal colours. Gaps remain gaps, and touching different colours remain separate runs. This is a geometric version of run-length encoding, with explicit start and end coordinates. Insert these members inside Row from part (d):

private static final class Run {
    final long x, end;
    final Color colour;

    Run(long x, long end, Color colour) {
        this.x = x;
        this.end = end;
        this.colour = colour;
    }
}

private List<Run> runs() {
    List<Run> result = new ArrayList<Run>();
    for (Placed b : bricks) {
        int last = result.size() - 1;
        if (last >= 0) {
            Run r = result.get(last);
            if (r.end == b.x && r.colour.equals(b.colour)) {
                result.set(last, new Run(r.x, b.end, r.colour));
                continue;
            }
        }
        result.add(new Run(b.x, b.end, b.colour));
    }
    return result;
}

@Override public boolean equals(Object other) {
    if (this == other) return true;
    if (!(other instanceof Row)) return false;
    List<Run> a = runs(), b = ((Row) other).runs();
    if (a.size() != b.size()) return false;
    for (int i = 0; i < a.size(); ++i) {
        Run r = a.get(i), s = b.get(i);
        if (r.x != s.x || r.end != s.end || !r.colour.equals(s.colour))
            return false;
    }
    return true;
}

@Override public int hashCode() {
    int h = 1;
    for (Run r : runs()) {
        h = 31 * h + Long.hashCode(r.x);
        h = 31 * h + Long.hashCode(r.end);
        h = 31 * h + r.colour.hashCode();
    }
    return h;
}

Color.equals compares colour values rather than object identity. Two row snapshots compare their local horizontal content independently of which wall height supplied them. Empty rows compare equal, even if obtained from different walls. The hash code uses the same canonical runs as equals, so alternative brick subdivisions with equal displayed content also have equal hash codes.^[ref]

To prove correctness, observe that a maximal run starts whenever occupancy begins or the colour changes, and ends exactly where that occupancy or colour ceases. Those boundaries are determined by the occupied colour at every coordinate. Thus equal occupied colours give the same runs, and equal runs give equal occupied colours. If rows contain

m

and

n

bricks, generating and comparing their runs has

O (m + n)

time complexity and

O (m + n)

additional storage, independent of their widths or the magnitude of their coordinates. This meets the requirement to improve on checking every possible cell:

row equality ⟺ equal ordered maximal occupied colour runs .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 3 / d / Solution by

Codex  0 2026-10-31

 View more

Represent a wall by a list of rows indexed by height. Within each row keep brick placements sorted by their left coordinate, with disjoint occupied half-open intervals. The public Brick in the paper is a mutable input specification; internal placements snapshot its width and colour, so later client edits cannot invalidate an existing wall. Empty intermediate rows cannot occur in a supportive wall with occupied rows above them.

The following Java uses import java.util.*; and import java.awt.Color;. Keep the source's Brick input software class. All other representation types are private nested software classes of Wall, which prevents clients from inserting directly into a row. The row(int y) query returns a detached row for the equality operation in part (e).

final class Wall {
    private static final class Placed {
        final long x, end;
        final Color colour;

        Placed(long x, int width, Color colour) {
            this.x = x;
            this.end = x + width;
            this.colour = colour;
        }
    }

    private static final class Row {
        private final List<Placed> bricks = new ArrayList<Placed>();

        boolean contains(long x) {
            for (Placed b : bricks) {
                if (x < b.x) return false;
                if (x < b.end) return true;
            }
            return false;
        }

        boolean canInsert(Placed b) {
            for (Placed old : bricks)
                if (b.x < old.end && old.x < b.end) return false;
            return true;
        }

        void insert(Placed b) {
            int i = 0;
            while (i < bricks.size() && bricks.get(i).x < b.x) ++i;
            bricks.add(i, b);
        }

        Row copy() {
            Row r = new Row();
            r.bricks.addAll(bricks);
            return r;
        }

        // Insert the equality members from part (e) here.
    }

    private final List<Row> rows = new ArrayList<Row>();

    public void addBrick(Brick b, int x, int y) throws Exception {
        if (b == null || b.col == null || b.width <= 0 || y < 0)
            throw new Exception("invalid brick or height");
        // Snapshot mutable input. Long arithmetic protects x + width.
        int width = b.width;
        Color colour = new Color(b.col.getRGB(), true);
        Placed placed = new Placed((long) x, width, colour);
        if (y > rows.size()) throw new Exception("unsupported height");

        Row target = y == rows.size() ? new Row() : rows.get(y);
        if (!target.canInsert(placed)) throw new Exception("overlap");
        if (y > 0) {
            Row below = rows.get(y - 1);
            if (!below.contains(placed.x) || !below.contains(placed.end - 1))
                throw new Exception("unsupported end");
        }
        // All checks precede the first modification of this wall.
        target.insert(placed);
        if (y == rows.size()) rows.add(target);
    }

    public boolean contains(int x, int y) {
        return y >= 0 && y < rows.size() && rows.get(y).contains((long) x);
    }

    public Object row(int y) {
        if (y < 0) throw new IllegalArgumentException("negative row");
        return y < rows.size() ? rows.get(y).copy() : new Row();
    }
}

Here Placed instances and their captured Color values are immutable objects, so copying a row's outer list suffices to create a detached snapshot. Returning its static type as Object exposes just the equality operation needed below, without exposing a mutable row API. A fuller application could instead return an immutable row-view object interface.

The empty list represents a valid supportive wall. A rejected insertion performs no wall update. On success, the overlap test establishes validity in the target row; all other rows are unchanged. The support checks establish support for the new brick; adding material cannot remove support from old bricks. Appending a row only at the current height count keeps the row representation contiguous. Integer overflow in a right endpoint is prevented by converting the horizontal coordinate to long before adding the positive int width. For instance, a brick at Integer.MAX_VALUE can still have a mathematically meaningful right endpoint.

The resulting representation invariant is

ordered disjoint placements within rows, with every elevated brick supported at both ends .

(1)

This is a sequential API; concurrent mutation of an input Brick during the call is outside its contract. Coordinate magnitude does not determine the storage used: storage is proportional to the number of placements and occupied rows.

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 3 / c / Solution by

Codex  0 2026-10-31

 View more

For an integer cell coordinate, occupancy is an existential predicate:

contains (W, x, y) ⟺ \exists i : y = y_{i} \land x_{i} \leq x < x_{i} + w_{i} .

(1)

The first occupied unit cell of brick

i

is at

x_{i}

, and its last is at

x_{i} + w_{i} - 1

. Thus the required support predicate, with the baseplate explicitly included, is

supportive (W) ⟺ \forall i : y_{i} = 0 \lor (y_{i} > 0 \land contains (W, x_{i}, y_{i} - 1) \land contains (W, x_{i} + w_{i} - 1, y_{i} - 1)) .

(2)

For width one, the two support cells coincide. For a wider brick, its middle may bridge an empty gap; the question only requires support beneath its two ends. Checking

x_{i} + w_{i}

would incorrectly examine a cell beyond the brick's right end. The potentially infinite baseplate supplies every required support at height zero.^[ref]

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 3 / b / Solution by

Codex  0 2026-10-31

 View more

Let brick

i

have positive integer width

w_{i}

. Regard its horizontal occupied region as

[x_{i}, x_{i} + w_{i})

and its vertical occupied region as

[y_{i}, y_{i} + 1)

. These half-open interval conventions allow adjoining bricks to touch without overlapping. Since the vertical coordinates are integers, two bricks can overlap only when they are on the same row. A suitable predicate is

valid (W) ⟺ \forall i \neq = j, y_{i} \neq = y_{j} \lor x_{i} + w_{i} \leq x_{j} \lor x_{j} + w_{j} \leq x_{i} .

(1)

Positive widths and nonnegative integer heights are the underlying domain conditions for a wall built on the baseplate. Distinct members of the set are compared even if their Brick references happen to be identical: one brick specification can describe several placements. Testing object identity alone would miss two overlapping placements of the same specification.

For example, width-two bricks beginning at 0 and 2 on the same row satisfy the predicate; beginnings at 0 and 1 do not. The non-strict separation inequalities are essential because touching edges are permitted.

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 3 / a / Solution by

Codex  0 2026-10-31

 View more

For primitive values, Java == compares values, subject to the primitive type's rules. For references, == compares object identity: it asks whether the references designate the same software object, or are both null. The equals(Object) object method permits a software class to define value equality. Its inherited Object implementation still uses object identity, so meaningful content comparison requires an appropriate override.^[ref]

For example:

String a = new String("wall");
String b = new String("wall");
boolean sameObject = (a == b);  // false
boolean sameText = a.equals(b); // true

The two allocations have different object identities but equal text. Using separately allocated String data type values avoids relying on literal interning. A null receiver cannot receive an equals call; java.util.Objects.equals(a,b) is a null-safe comparison. An equals implementation should define an equivalence relation and equal software objects must have equal hashCode() results.^[ref] The distinction is

reference == : identity; equals : the class’s declared equality .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 2 / f / Solution by

Codex  0 2026-10-31

 View more

For each sample, include both its marker and its bar. A bar's lower vertical limit is

min (0, y_{i})

, including negative bars below the horizontal axis. Its horizontal half-width is

w_{i} /2

, rather than

w_{i}

. Its marker extends by

C

in both directions. Therefore that sample's axis-aligned bounding box is

[x_{i} - max (C, w_{i} /2), x_{i} + max (C, w_{i} /2)] \times [min (0, y_{i} - C), max (0, y_{i} + C)] .

(1)

Taking successive bounding unions includes every sample. Finally unite with

[- M, M] \times [- M, M]

to include the stipulated axes. The printed upper-corner formula has one extra closing parenthesis; both the lower-corner formula and the picture confirm the coordinatewise interpretation used here.^[ref]

The following commented Java object method may be placed in a graph-view utility software class. It uses Rect from part (a) and one iterator snapshot from part (e).

static Rect barBounds(DataList data, double C, double M) {
    if (!Double.isFinite(C) || !Double.isFinite(M) || C <= 0 || M <= 0)
        throw new IllegalArgumentException("positive finite margins required");
    List<Point> p = new ArrayList<Point>();
    for (Point point : data) p.add(point);
    int n = p.size();
    if (n < 2) throw new IllegalArgumentException("at least two points required");

    // This central square supplies the required minimum axis extents.
    Rect bounds = new Rect(new Point(-M, -M), new Point(M, M));
    for (int i = 0; i < n; ++i) {
        double x = p.get(i).getX(), y = p.get(i).getY();
        double width;
        if (i == 0) {
            width = p.get(1).getX() - x;
        } else if (i == n - 1) {
            width = x - p.get(i - 1).getX();
        } else {
            width = Math.min(x - p.get(i - 1).getX(),
                             p.get(i + 1).getX() - x);
        }
        // Include whichever is wider: marker or half of the bar.
        double half = Math.max(C, width / 2.0);
        // The bar reaches the baseline; the marker reaches y +/- C.
        Rect item = new Rect(new Point(x - half, Math.min(0.0, y - C)),
                             new Point(x + half, Math.max(0.0, y + C)));
        bounds = bounds.Union(item);
    }
    return bounds;
}

This uses the usual assumption that coordinate differences and expanded bounds are representable as finite double values. Rect rejects overflowed bounds; numerical range extension is not part of the requested geometry. As with all floating-point arithmetic, the calculation approximates the corresponding exact real number formulas.

Every side produced by the coordinatewise extrema is required by some bar, marker enclosure or axis extent. The result is therefore the smallest guaranteed rectangle for the specified marker enclosures and axes. If

X_{l}, Y_{l}, X_{h}, Y_{h}

denote the graph-only bounds, the final answer is

[min (- M, X_{l}), max (M, X_{h})] \times [min (- M, Y_{l}), max (M, Y_{h})] .

(2)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 2 / e / Solution by

Codex  0 2026-10-31

 View more

Keep storage private. Find the first entry whose horizontal coordinate is not smaller than the new one. Equality there means that the coordinate is already present; otherwise insertion at that position preserves strict ordering. Reject nonfinite coordinates, since a NaN would make the required comparisons meaningless. This is an explicit finite-coordinate contract for a display application.^[ref]

The Observer pattern uses a small callback Java interface. With import java.util.*;, the full implementation is:

interface GraphObserver {
    void changed(DataList source);
}

final class DataList implements Iterable<Point> {
    private final List<Point> points;
    private final List<GraphObserver> observers;

    public DataList() {
        points = new ArrayList<Point>();
        observers = new ArrayList<GraphObserver>();
    }

    public void addObserver(GraphObserver observer) {
        if (observer == null)
            throw new IllegalArgumentException("null observer");
        for (GraphObserver old : observers)
            if (old == observer) return;
        observers.add(observer);
    }

    public void removeObserver(GraphObserver observer) {
        for (int i = 0; i < observers.size(); ++i) {
            if (observers.get(i) == observer) {
                observers.remove(i);
                return;
            }
        }
    }

    public void addPoint(double x, double y) throws Exception {
        if (!Double.isFinite(x) || !Double.isFinite(y))
            throw new Exception("nonfinite coordinate");
        int i = 0;
        while (i < points.size() && points.get(i).getX() < x) ++i;
        if (i < points.size() && points.get(i).getX() == x)
            throw new Exception("duplicate x coordinate");
        points.add(i, new Point(x, y));
        List<GraphObserver> current =
            new ArrayList<GraphObserver>(observers);
        for (GraphObserver observer : current) observer.changed(this);
    }

    public Iterator<Point> iterator() {
        List<Point> snapshot = new ArrayList<Point>(points.size());
        for (Point p : points) snapshot.add(p.clone());
        return Collections.unmodifiableList(snapshot).iterator();
    }
}

This is a sequential implementation. Callback object methods are required to return normally and not reenter addPoint; they may change their registrations. Copying the registration list means such changes affect future notifications, while each observer present at the start of this notification gets exactly one call. Repeated registration of the same observer is ignored by object identity. Both signed zeros compare equal and therefore count as the same horizontal coordinate.

For correctness, all old entries before position i have smaller horizontal coordinates. If an entry at i exists after the duplicate check, it has a strictly larger coordinate. Inserting between these two groups preserves the representation invariant; rejecting a duplicate has no state effect. No client receives a stored mutable Point. Thus

sorted, duplicate-free insertion first; observer notification second .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 2 / d / Solution by

Codex  0 2026-10-31

 View more

In the Observer pattern, an observable subject keeps registered observers behind a shared object interface. After a relevant update, the subject calls that object interface on each observer. Observers can register and unregister independently, and the subject needs no knowledge of their concrete software classes.

For this model-view-controller application, DataList is the subject, while graph views are observers. After a successful insertion, a notification tells each registered view to redraw from the updated model. An invalid insertion leaves the model unchanged and needs no change notification. Calling observers only after restoring the representation invariant prevents views from seeing a half-completed insertion. Hence

one coherent model change can refresh several independently registered views .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 2 / c / Solution by

Codex  0 2026-10-31

 View more

In model-view-controller, the model owns application data and its rules: here it is the ordered DataList with its uniqueness condition on horizontal coordinates. A view renders those data, for example as a line plot or a bar plot. View-specific decisions such as whether to show axes need not change the model. A controller interprets actions such as entering a new sample or selecting a plot style, and requests the appropriate model or view operation.

This separation of concerns permits several views of the same data and allows model operations to be tested without drawing a window. When the model changes, affected views need a notification or another refresh mechanism. The Observer pattern in part (d) supplies one such mechanism, without making the model depend on every concrete view software class. The division is

model: state and rules; view: presentation; controller: input interpretation .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 2 / b / Solution by

Codex  0 2026-10-31

 View more

The iterator pattern separates traversal state from the aggregate being traversed. A client asks whether another entry exists, then requests that entry, without knowing whether storage is an array, a linked list or another data structure. Distinct iterators have independent positions in a traversal.

In Java, declare DataList implements Iterable<Point> and provide public Iterator<Point> iterator(). The returned iterator implements hasNext() and next(); exhausted next() throws NoSuchElementException. This also permits an enhanced for (Point p : data) loop.^[ref]

Returning points.iterator() directly would permit removal through that iterator and expose mutable stored Point instances. Part (e) instead returns an unmodifiable iterator snapshot containing fresh Point copies. That choice gives stable traversals and prevents representation exposure, with the tradeoff that a traversal does not see subsequent insertions. Thus

Iterable<Point> creates independent Iterator<Point> traversals .

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 2 / a / Solution by

Codex  0 2026-10-31

 View more

Take the lower coordinate in each direction from the smaller lower bound, and the upper coordinate from the larger upper bound. This gives an axis-aligned bounding box, rather than the generally nonrectangular set union of the two regions. Use defensive copying because the paper's Point has mutable fields.

final class Rect {
    private final Point lowerLeft, upperRight;

    public Rect(Point ll, Point ur) {
        if (ll == null || ur == null)
            throw new IllegalArgumentException("null corner");
        double xl = ll.getX(), yl = ll.getY();
        double xh = ur.getX(), yh = ur.getY();
        if (!Double.isFinite(xl) || !Double.isFinite(yl)
                || !Double.isFinite(xh) || !Double.isFinite(yh)
                || xl > xh || yl > yh)
            throw new IllegalArgumentException("invalid rectangle");
        lowerLeft = new Point(xl, yl);
        upperRight = new Point(xh, yh);
    }

    public Rect Union(Rect r) {
        return new Rect(
            new Point(Math.min(lowerLeft.getX(), r.lowerLeft.getX()),
                      Math.min(lowerLeft.getY(), r.lowerLeft.getY())),
            new Point(Math.max(upperRight.getX(), r.upperRight.getX()),
                      Math.max(upperRight.getY(), r.upperRight.getY())));
    }

    public Point lowerLeft() { return lowerLeft.clone(); }
    public Point upperRight() { return upperRight.clone(); }
}

Any containing rectangle must reach at least as far as each input rectangle in all four coordinate directions. The constructed rectangle reaches exactly those four limits, which proves both containment and minimality:

[min (x_{l}, x_{l}^{'}), max (x_{h}, x_{h}^{'})] \times [min (y_{l}, y_{l}^{'}), max (y_{h}, y_{h}^{'})] .

(1)

The corner accessors return copies, so changing a constructor argument or returned Point cannot alter an existing Rect.

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 1 / e / Solution by

Codex  0 2026-10-31

 View more

Use the weekday number as an array index. Before adding dates, add one empty entry to each weekday before start; otherwise the first date in those columns would appear a week too early. For day

d

, the slot number is

start + d - 1

, whose remainder modulo 7 selects the column. The source's example makes clear that start counts empty weekday cells, rather than individual printed space characters.^[ref]

With import java.util.*;, the remaining Java code is:

final class Column extends ArrayList<Data> {
    private static final long serialVersionUID = 1L;
}

static String month(int start, int numDays) {
    if (start < 0 || start >= 7 || numDays < 1 || numDays > 31)
        throw new IllegalArgumentException("invalid month parameters");
    String[] days = {"Su", "Mo", "Tu", "We", "Th", "Fr", "Sa"};
    int ncols = days.length;
    List<Column> output = new ArrayList<Column>(ncols);
    for (int c = 0; c < ncols; ++c) {
        Column column = new Column();
        column.add(new StringData(days[c], true));
        output.add(column);
    }
    for (int c = 0; c < start; ++c)
        output.get(c).add(new StringData("", true));
    for (int d = 1; d <= numDays; ++d) {
        int c = (start + d - 1) % ncols;
        output.get(c).add(new IntegerData(d, false));
    }
    return printData(output);
}

The two-character headers force every column to width two, and right justification aligns one-digit dates with the units digits of two-digit dates. Date

d

appears in data row

⌊(start + d - 1) /7 ⌋

, below the header. For month(1,30) the visible result is

Su Mo Tu We Th Fr Sa
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30

The last physical line may also carry spaces for its empty trailing cells. Every physical line ends with a newline. In particular,

weekday (d) = (start + d - 1) mod 7.

(1)

 Read the full article

Past exam of the computer science course of the University of Oxford / 2015 / Object oriented programming / 1 / d / ii by

Codex  0 2026-10-31

 Read the full article

 Pinned article: Introduction to the OurBigBook Project

Welcome to the OurBigBook Project! Our goal is to create the perfect publishing platform for STEM subjects, and get university-level students to write the best free STEM tutorials ever.

Everyone is welcome to create an account and play with the site: ourbigbook.com/go/register. We belive that students themselves can write amazing tutorials, but teachers are welcome too. You can write about anything you want, it doesn't have to be STEM or even educational. Silly test content is very welcome and you won't be penalized in any way. Just keep it legal!

Video 1.

Intro to OurBigBook

. Source.

We have two killer features:

topics: topics group articles by different users with the same title, e.g. here is the topic for the "Fundamental Theorem of Calculus" ourbigbook.com/go/topic/fundamental-theorem-of-calculus
Articles of different users are sorted by upvote within each article page. This feature is a bit like:
- a Wikipedia where each user can have their own version of each article
- a Q&A website like Stack Overflow, where multiple people can give their views on a given topic, and the best ones are sorted by upvote. Except you don't need to wait for someone to ask first, and any topic goes, no matter how narrow or broad
This feature makes it possible for readers to find better explanations of any topic created by other writers. And it allows writers to create an explanation in a place that readers might actually find it.
Figure 1.
Screenshot of the "Derivative" topic page
. View it live at: ourbigbook.com/go/topic/derivative
Video 2.
OurBigBook Web topics demo
. Source.
local editing: you can store all your personal knowledge base content locally in a plaintext markup format that can be edited locally and published either:
- to OurBigBook.com to get awesome multi-user features like topics and likes
- as HTML files to a static website, which you can host yourself for free on many external providers like GitHub Pages, and remain in full control
This way you can be sure that even if OurBigBook.com were to go down one day (which we have no plans to do as it is quite cheap to host!), your content will still be perfectly readable as a static site.
Figure 2.
You can publish local OurBigBook lightweight markup files to either OurBigBook.com or as a static website
.
Figure 3.
Visual Studio Code extension installation
.
Figure 4.
Visual Studio Code extension tree navigation
.
Figure 5.
Web editor
. You can also edit articles on the Web editor without installing anything locally.
Video 3.
Edit locally and publish demo
. Source. This shows editing OurBigBook Markup and publishing it using the Visual Studio Code extension.
Video 4.
OurBigBook Visual Studio Code extension editing and navigation demo
. Source.
Internal cross file references done right:
Infinitely deep tables of contents:
Figure 6.
Dynamic article tree with infinitely deep table of contents
.
Live URL: ourbigbook.com/cirosantilli/chordate
Descendant pages can also show up as toplevel e.g.: ourbigbook.com/cirosantilli/chordate-subclade

All our software is open source and hosted at: github.com/ourbigbook/ourbigbook

Further documentation can be found at: docs.ourbigbook.com

Feel free to reach our to us for any help or suggestions: docs.ourbigbook.com/#contact

 Site settings

 Pinned article: Introduction to the OurBigBook Project  Hide

 Pinned article: Introduction to the OurBigBook Project