Counting Up, Binary Numbers, and Recursive Practice

1. Counting Up, Binary Numbers, and Recursive Practice

Title

Think Java 2e · Chapter 8 · Recursive Methods

Sections 8.5-8.8 · pp. 134-140

2. What you will be able to do

Objectives

This lesson follows Think Java 2e, Chapter 8 (Recursive Methods), Sections 8.5-8.8, pp. 134-140. Everything on these slides can be checked against those pages.

1. Explain what changes when the recursive call comes before the work instead of after it.

2. Convert a decimal number to binary by repeated division, and read the remainders in the right order.

3. Write a recursive method that prints a number in binary, and say why the digits come out left to right.

4. Solve a recursive string problem by splitting off the first character and recursing on the rest.

5. Use an index parameter to recurse over an array, and identify the base case.

6. Recognise the shared shape: check the base case, handle the current item, recurse on the rest.

• 8.5 — Counting Up Recursively
• 8.6 — Binary Number System
• 8.7 — Recursive Binary Method
• 8.8 — CodingBat Problems

3. Retrieve before you read

Warm-up

One observation from the previous lesson is about to be exploited.

4. Before or after the recursive call

Concept

The countdown example has three parts: it checks the base case, it displays something, and it makes a recursive call. This lesson is largely about what happens when you reverse the last two.

• 8.5 — counting up, by moving one line
• 8.6 — the binary number system, and repeated division
• 8.7 — displayBinary, which needs the count-up pattern
• 8.8 — two CodingBat problems, one string and one array

Downey & Mayfield, Think Java, 2nd edition (Green Tea Press / O'Reilly, 2020) — Think Java 2e, Chapter 8 (Recursive Methods), Sections 8.5-8.8, pp. 134-140 — Sections 8.5-8.8, printed pages 134-140.

5. Counting up recursively

Section

Section 8.5

6. Move the print after the recursive call

Concept

The stack diagram is the same as before and the method is still called n times. But now the println happens just before each recursive call returns — so it counts up instead of down.

public static void countup(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        countup(n - 1);
        System.out.println(n);
    }
}

The output is Blastoff!, then 1, 2, 3. Nothing about the recursion changed — the same four calls happen in the same order, and the same four frames appear. Only the moment of printing moved.

7. The same stack, the opposite output

Picture it

Draw both and the frames are identical. What differs is which frames have already printed by the time you reach the bottom.

At this moment — the deepest point — countdown would already have printed 3, 2, 1 and be about to print Blastoff! countup has printed nothing at all yet. The first thing it prints is Blastoff!, and the numbers follow as the frames unwind from the bottom up.

8. Tracing countup(3)

Worked example

Follow it down first, noticing that nothing is printed, and then watch the output appear as the calls return.

public static void countup(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        countup(n - 1);
        System.out.println(n);
    }
}

9. What does countup(2) print?

Prediction

The recursive call comes first.

public static void countup(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        countup(n - 1);
        System.out.println(n);
    }
}

10. Why the reversal happens

Concept

The calls always start outermost-first. The returns always happen innermost-first. So work placed before the call runs in call order, and work placed after it runs in reverse.

The last row is worth knowing about: a method with a print on both sides of the recursive call produces the sequence down and then back up again. Many algorithms perform computations on the way down, on the way up, or both — and choosing which is a design decision, not an accident.

11. Expecting the output order to match the call order

Trap

public static void countup(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        countup(n - 1);
        System.out.println(n);
    }
}

// before the call -> runs on the way DOWN, in call order
System.out.println(n);
countdown(n - 1);

// after the call -> runs on the way UP, in reverse order
countup(n - 1);
System.out.println(n);

12. Down or up?

Definition probe

Decide from where the work sits relative to the recursive call.

13. How many frames does countup(3) use?

Prediction

Compare against countdown.

14. Why can a frame do work after its recursive call?

Socratic

It sounds as though the frame should be finished.

15. The binary number system

Section

Section 8.6

16. Place values, in base two

Concept

Computers store only 1s and 0s, because processors and memory are made of billions of tiny on-off switches. Fortunately we can represent any integer as a binary number — and the written representation works exactly like decimal, with powers of two instead of powers of ten.

// decimal 456 - powers of ten
//     4        5        6
//    10^2     10^1     10^0      = 400 + 50 + 6

// binary 10111 - powers of two
//     1    0    1    1    1
//    2^4  2^3  2^2  2^1  2^0     = 16 + 0 + 4 + 2 + 1 = 23

In decimal there are ten digits and the places are powers of ten. In binary there are two digits and the places are powers of two. Everything else about reading a number is identical.

17. Reading 10111

Picture it

Label each column with its place value, multiply, and add. The method is the one you already use for decimal.

Only the columns with a 1 contribute. That is what makes binary arithmetic simple for a machine — each place is either counted or not, which is exactly what a switch can represent.

18. Converting 23 to binary by repeated division

Worked example

To get the digits of a decimal number you can use repeated division by ten. The same method works in binary if you divide by two — and both operators come from Lesson 3b.

23 / 2 is 11 remainder 1
11 / 2 is  5 remainder 1
 5 / 2 is  2 remainder 1
 2 / 2 is  1 remainder 0
 1 / 2 is  0 remainder 1

19. What is 1101 in decimal?

Prediction

Label the places with powers of two.

//  1    1    0    1
//  8    4    2    1

20. The two operators, doing exactly their jobs

Concept

This algorithm is Lesson 3b's quotient-and-remainder pattern, applied repeatedly. The same two operators that split inches into feet split a number into its digits.

Lesson 3b noted that x % 10 yields the rightmost decimal digit. Dividing by 2 instead of 10 gives the rightmost binary digit, for exactly the same reason. Recognising an old pattern in a new base is worth more than memorising the conversion.

21. Reading the remainders in the order you computed them

Trap

// remainders, in the order computed:
//   1, 1, 1, 0, 1
// read that way:  11101 = 29    WRONG

// 23 / 2 = 11 r 1     <- rightmost digit
// 11 / 2 =  5 r 1
//  5 / 2 =  2 r 1
//  2 / 2 =  1 r 0
//  1 / 2 =  0 r 1     <- leftmost digit
//
// reading up:  1 0 1 1 1  =  10111

22. What is the rightmost binary digit of 10?

Prediction

The remainder after dividing by two.

10 % 2

23. Order the steps of converting 6 to binary

Ranking

Repeated division, then read the remainders.

24. Why does the machine use binary at all?

Real world

Decimal is more convenient for people. The machine's choice is about physics.

25. The recursive binary method

Section

Section 8.7

26. Divide on the way down, print on the way up

Concept

To display a number in binary, combine the repeated-division algorithm with the count-up pattern from Section 8.5. The recursion divides going down; the printing happens coming back.

public static void displayBinary(int value) {
    if (value > 0) {
        displayBinary(value / 2);
        System.out.print(value % 2);
    }
}

If value is 0, displayBinary does nothing — that is the base case. Otherwise it divides by 2, calls itself, and when the recursive call returns displays one digit.

27. The leftmost digit is at the bottom of the stack

Picture it

The stack holds the divisions; the printing happens as it unwinds, so the last division printed is the first one made.

The leftmost digit is near the bottom of the stack, so it gets displayed first. The rightmost digit, near the top, gets displayed last. That is exactly the reversal the count-up pattern provides — and it is why the digits come out in the right order without any array or string to hold them.

28. Tracing displayBinary(23)

Worked example

Six calls going down, five digits coming back. Watch which frame prints which digit.

public static void displayBinary(int value) {
    if (value > 0) {
        displayBinary(value / 2);
        System.out.print(value % 2);
    }
}

Note the println() after the call: displayBinary uses print, so it never ends the line itself.

29. What does displayBinary(5) print?

Prediction

Divide down, print up.

public static void displayBinary(int value) {
    if (value > 0) {
        displayBinary(value / 2);
        System.out.print(value % 2);
    }
}

30. Why print after, and not before

Concept

Swapping the two lines would give a method that compiles, runs and prints the digits backwards. The position of the recursive call is doing all the work.

// correct: digits left to right
displayBinary(value / 2);
System.out.print(value % 2);

// swapped: digits right to left
System.out.print(value % 2);
displayBinary(value / 2);

The second version produces the digits in the order the divisions computed them, which is backwards. Both are one-line methods and the difference between them is entirely which side of the recursive call the print sits on — the question from the first idea of this lesson.

31. A base case of value == 0 that prints

Trap

public static void displayBinary(int value) {
    if (value == 0) {
        System.out.print(0);        // wrong: prints a leading 0
    } else {
        displayBinary(value / 2);
        System.out.print(value % 2);
    }
}

public static void displayBinary(int value) {
    if (value > 0) {
        displayBinary(value / 2);
        System.out.print(value % 2);
    }
}

32. What if the print came first?

Prediction

Swap the two lines.

System.out.print(value % 2);
displayBinary(value / 2);

33. Complete displayBinary

Fill the middle

Print the digits left to right.

34. Why does this need recursion rather than a loop?

Explain it to yourself

The repeated division is easy to write as a loop. Something else is not.

35. Recursion over a string

Section

Section 8.8

36. Split off the first character, recurse on the rest

Concept

CodingBat's noX problem: given a string, compute recursively a new string with all the 'x' characters removed. When solving recursive problems it helps to think about the base case first.

// noX("xaxb") -> "ab"
// noX("abc")  -> "abc"
// noX("xx")   -> ""

if (str.length() == 0) {
    return "";                    // the base case
}

char first = str.charAt(0);       // split into
String rest = str.substring(1);   // first and rest

The base case is the easiest version of the problem: for noX it is the empty string, which has no x's to remove, so the answer is the empty string. Then split the string into two parts — the first letter and the rest — using charAt and substring from Lesson 6b.

37. The whole method, built in four moves

Notation

To solve a problem recursively you need to think of a simpler instance of the same problem. For noX that is removing the x's from a shorter string.

Four moves, and only the third involves any faith. The base case and the split can both be checked by reading.

38. Tracing noX on "xab"

Worked example

Follow it down to the empty string, then watch the result being rebuilt on the way up.

public static String noX(String str) {
    if (str.length() == 0) {
        return "";
    }
    char first = str.charAt(0);
    String rest = str.substring(1);
    String recurse = noX(rest);
    if (first == 'x') {
        return recurse;
    } else {
        return first + recurse;
    }
}

39. What does noX("xxa") return?

Prediction

Trace down, then rebuild.

public static String noX(String str) {
    if (str.length() == 0) {
        return "";
    }
    char first = str.charAt(0);
    String rest = str.substring(1);
    String recurse = noX(rest);
    if (first == 'x') {
        return recurse;
    } else {
        return first + recurse;
    }
}

40. Building a string on the way up

Concept

Notice that noX never reverses anything, even though it takes the string apart from the front. The stack handles the ordering, exactly as it did for displayBinary.

Each character is put back on the front of the result, and the characters come back in reverse order — so the two reversals cancel and the string comes out the right way round. That is the same mechanism as the binary digits, in a different costume.

41. Recursing on the wrong part

Trap

public static String noX(String str) {
    if (str.length() == 0) {
        return "";
    }
    char first = str.charAt(0);
    String recurse = noX(str);      // str, not the rest
    ...
}

String rest = str.substring(1);
String recurse = noX(rest);

42. Order the steps of a recursive string method

Ranking

The shape that solves nearly every problem of this kind.

43. Complete noX

Fill the middle

Drop the x, keep everything else.

44. What happens if the base case is checked last?

Edge cases

Order matters more than usual here.

45. Recursion over an array

Section

Section 8.8, continued

46. Pass the index as an argument

Concept

CodingBat's array11: given an array of ints, compute recursively the number of times the value 11 appears. An array cannot be shortened the way a string can, so this problem uses a different convention: pass the index as an argument.

// array11([1, 2, 11], 0)  -> 1
// array11([11, 11], 0)    -> 2
// array11([1, 2, 3, 4], 0) -> 0

if (index >= nums.length) {
    return 0;                 // base case: past the end
}

The base case is when we have reached the end of the array — at that point we know there are no more 11s, so the answer is 0. The index moving forward is what makes progress toward it.

47. The index is the shrinking part

Picture it

Nothing about the array changes. What shrinks is the amount of it still to be looked at, and the index records where that starts.

Each call handles one element — the one at index — and trusts the recursion for everything after it. The array itself is passed unchanged every time, which is cheap because what is passed is a reference (Lesson 7a).

48. Tracing array11

Worked example

Similar to noX, we look at only one integer per method call. Follow it to the end of the array and count back.

public static int array11(int[] nums, int index) {
    if (index >= nums.length) {
        return 0;
    }
    int recurse = array11(nums, index + 1);
    if (nums[index] == 11) {
        return recurse + 1;
    } else {
        return recurse;
    }
}

49. What does array11 return?

Prediction

Count on the way back.

public static int array11(int[] nums, int index) {
    if (index >= nums.length) {
        return 0;
    }
    int recurse = array11(nums, index + 1);
    if (nums[index] == 11) {
        return recurse + 1;
    } else {
        return recurse;
    }
}

50. One shape, two problems

Concept

Both CodingBat problems have the same recursive idea: check the base case, look at the current item, and recursively handle the rest. Only the details of each step differ.

Reading the table down each column gives a complete method. Reading it across shows that they are the same method applied to two different structures — which is what it means to have learned a pattern rather than two solutions.

51. Forgetting to use the recursive result

Trap

int recurse = array11(nums, index + 1);
if (nums[index] == 11) {
    return 1;                    // ignores recurse
} else {
    return 0;                    // ignores it too
}

int recurse = array11(nums, index + 1);
if (nums[index] == 11) {
    return recurse + 1;
} else {
    return recurse;
}

52. Which part plays which role?

Definition probe

The same three roles as every recursive method.

53. Match the string version to the array version

Matching

The same pattern, two structures.

54. Why not shorten the array instead?

Counterexample

The string version passes a shorter string. Ask why the array version does not.

55. The recursive pattern, across three problems

Comparison

Fill the blanks. Every column is the same four questions with different answers.

All three do their work on the way up, which is why all three needed the count-up pattern from Section 8.5. That one observation about line order carries the whole lesson.

56. The pattern to carry away

Pattern

Check the base case, look at the current item, recursively handle the rest. Both CodingBat problems are this, and so is almost every recursive problem over a sequence.

ReturnType solve(Data data, position p) {

    if (pastTheEnd(p)) {              // 1. base case
        return emptyAnswer;           //    "" for strings, 0 for counts
    }

    Item current = itemAt(data, p);   // 2. the current item
    ReturnType rest = solve(data, next(p));   // 3. recurse on the rest

    return combine(current, rest);    // 4. combine
}

• Work before the recursive call runs on the way down; after it, on the way up.
• The stack reverses the order for free — which is why displayBinary needs no array.
• Check the base case before anything that assumes non-emptiness, such as charAt(0).
• Always use the recursive result, or the recursion is doing nothing.

57. Check: countup

Check

Work it out before you click.

public static void countup(int n) {
    if (n == 0) {
        System.out.println("Blastoff!");
    } else {
        countup(n - 1);
        System.out.println(n);
    }
}

58. Check: binary conversion

Check

Work it out before you click.

6 / 2 is 3 remainder 0
3 / 2 is 1 remainder 1
1 / 2 is 0 remainder 1

59. Check: the recursive result

Check

Work it out before you click.

public static int count(int[] nums, int index) {
    if (index >= nums.length) {
        return 0;
    }
    int recurse = count(nums, index + 1);
    if (nums[index] == 7) {
        return recurse + 1;
    }
    return recurse;
}

60. The stack as a free reversal

Real world

Two methods in this lesson needed their results in the opposite order from the one they were computed in, and neither used an array to reverse anything.

61. How sure are you?

Commit first

Commit to an answer and to your confidence.

62. Explain it to someone else

Explain it

Two minutes, drawing as you go.

63. Exit ticket

Exit ticket

One question before you close the deck.

64. Draw the whole lesson

Connect it up

One page, from memory.

65. Recap

Recap

Four sections that turn recursion from a curiosity into a technique — and one observation about line order that explains all four.

• Work before the recursive call happens on the way down; work after it happens on the way up.
• countup is countdown with two lines swapped, and its output is the exact reverse.
• Binary place values are powers of two, and repeated division by 2 produces the digits rightmost-first.
• displayBinary prints on the way up, so the leftmost digit — computed last — is displayed first.
• The base case must be checked first, before anything that assumes the data is non-empty.
• For a string, recurse on substring(1); for an array, pass index + 1.
• Always combine the recursive result with the current item's contribution.
• The stack reverses order for free, which is a genuine reason to choose recursion.