Casework

The category

Some problems have no single formula. Instead there are a few distinct situations, each with its own answer, and the work is identifying them and handling each correctly.

The risk is not that any one case is hard. It is that you miss one, or that two of your cases overlap and you count something twice.

Enumerate before you code

Write the cases down as a list before writing any code. If you cannot list them, you do not yet understand the problem well enough to implement it.

Three cows stand at distinct positions on a line. In one move, you may take either of the two outer cows and place it at any unoccupied integer position strictly between the other two. What is the maximum number of moves?

Work small examples by hand first.

int[] p = {a, b, c};
Arrays.sort(p);

int gapLeft  = p[1] - p[0] - 1;
int gapRight = p[2] - p[1] - 1;

if (gapLeft == 0 && gapRight == 0) {
    System.out.println(0);
} else {
    System.out.println(Math.max(gapLeft, gapRight));
}

Sorting first removes three cases immediately — you no longer need separate handling for each possible input order. Normalizing the input is often the cheapest way to collapse casework.

Checking coverage

Two properties are needed. Every input must fall into some case, and no input into two.

The third point is the most frequent failure. Writing if (x < 5) ... else if (x > 5) ... with no branch for equality compiles and runs and is wrong on exactly one input.

Overlapping regions

Two axis-aligned rectangles are given. Print the area covered by at least one of them.

Adding the two areas double-counts the intersection, so subtract it once. That single formula replaces a large amount of casework:

long area1 = (long)(x2 - x1) * (y2 - y1);
long area2 = (long)(x4 - x3) * (y4 - y3);

int overlapW = Math.max(0, Math.min(x2, x4) - Math.max(x1, x3));
int overlapH = Math.max(0, Math.min(y2, y4) - Math.max(y1, y3));
long overlap = (long) overlapW * overlapH;

System.out.println(area1 + area2 - overlap);

The Math.max(0, ...) is what handles the non-overlapping case without a branch. When the rectangles are disjoint the computed width or height is negative, and clamping it to zero makes the overlap zero. Finding an expression that absorbs a case is usually better than adding a branch for it.

This inclusion-exclusion idea generalizes; see Inclusion-Exclusion for the version with many sets.

Structuring the code

Once the cases are listed, write them in the same order, one branch each, with a comment naming the case.

if (n == 0) {
    // no cows: nothing to do
    out.println(0);
} else if (n == 1) {
    // single cow: it is trivially the answer
    out.println(a[0]);
} else if (allEqual(a)) {
    // every cow identical: no move changes anything
    out.println(-1);
} else {
    // general case
    out.println(solve(a));
}

Resist merging branches to make the code shorter. A five-branch if chain that matches your written case list is easier to check against the statement than a clever two-line expression.

Next