عرض عملي: التخطيط قبل الكود على مشكلة جديدة

Examples

The three examples in this lesson are three stages of one demo.

Example 1: read, restate, plan, list the edge cases (simple)

The problem: "Count how many words in a sentence are longer than 4 letters."

Step 1: restate. Given a sentence, count the words that have more than four letters. Inputs, outputs, and constraints:

Problem (my words):   Count the words of a text that have more than 4 letters.
Input:                String text
Output:               int count
Constraints:          What separates words? What is a "letter"? Empty text?
Questions/decisions:  Words are separated by one or more spaces.
                      Length 5 or more counts (more than 4).
                      Punctuation is not a letter (decision pending, see edge cases).
                      Empty text or only spaces -> 0.
Example by hand:      "plan before you write code" -> before (6), write (5) -> 2

Step 2: plan. Decomposition:

1. Cut the text into words.
2. Start a counter at 0.
3. For each word, if it has more than 4 letters, add 1.
4. Return the counter.

Pseudocode:

SET words = the words of text
SET count = 0
FOR EACH word IN words
    IF length of word > 4
        SET count = count + 1
RETURN count

Step 3: edge cases. Using the checklist:

The last two rows are the interesting ones. The last expects 2: Great and stuff have five letters each, while four! has four letters but five characters.

Example 2: trace, code, and find the bug (practical)

Step 4: trace. Trace the plan on the hand example plan before you write code:

The plan gives 2, as expected, and a word of length exactly 4 is not counted.

Step 5: code the first idea. Translating the plan directly gives:

static int countLongWordsV1(String text) {
    String[] words = text.split(" ");
    int count = 0;
    for (String w : words) {
        if (w.length() > 4) count++;
    }
    return count;
}

Step 6: run the list. Running version 1 over the inputs gave this:

Two surprises. First, the extra spaces did not cause a wrong answer. With split(" "), extra spaces produce empty pieces, but an empty piece has length 0, which is never above 4, so the count is unaffected. Before you "fix" something, check what it really does. (If the problem had been "count the words", the empty pieces would have broken it: " hello brave world " gives 8 pieces with split(" ") but 3 real words.)

Second, the last row is wrong: version 1 returned 3 instead of 2. The word four! has four letters but five characters, so counting length counts the punctuation. The edge-case list found this before any user did; a happy-path test would have passed.

Example 3: fix the plan, then the code, then check (realistic)

Go back to the plan, because the plan said "length of word", and length is not what we mean. We need a decision and a plan change.

Decision (recorded): a word's size is the number of letters in it; digits, punctuation, and other symbols do not count.

Updated pseudocode:

SET words = the words of trimmed text, split on runs of spaces
SET count = 0
FOR EACH word IN words
    IF the number of letters in word > 4
        SET count = count + 1
RETURN count

That adds a small step, "count the letters of a word", which we make its own method. To find out whether a character is a letter we use Character.isLetter, a library method that this course has not covered yet, so treat it as a preview: it takes one char and answers true or false. For splitting, we also use trim() and split("\\s+"). The pattern \\s+ is a regular expression meaning "one or more whitespace characters", another preview topic: for now, read it as "split on any run of spaces". Trimming first matters because a text that starts with spaces would otherwise give an empty first piece.

static int lettersIn(String w) {
    int n = 0;
    for (int i = 0; i < w.length(); i++) {
        if (Character.isLetter(w.charAt(i))) n++;
    }
    return n;
}

static int countLongWords(String text) {
    String[] words = text.trim().split("\\s+");
    int count = 0;
    for (String w : words) {
        if (lettersIn(w) > 4) count++;
    }
    return count;
}

Run the whole list again. Real results:

I also ran the other rows of the list on this version and they match their expected column (for example hello gives 1 and four fives gives 1). The plan and code now match line for line: SET words is the trim and split line, the loop is the loop, number of letters in word is lettersIn, and the counter is count.

One more detail the list made us look at: for empty text, "".trim().split("\\s+") gives an array holding one empty string, not an empty array, so the loop runs once with a zero-letter word and the count stays 0. (For a problem that counts words, empty text would wrongly give 1 and need an if.)