Warning. Other forms of loops

[comp1110-0R]
  • Liam O'Connor

In your prior programming experience(s), you may have seen other kinds of loops, such as for or do loops. While we don't demonstrate these loops in our examples for the first part of this course, you are permitted to use them in your own work.

In all cases, it is both possible and permissible to use while loops to solve looping problems.

Context

    Top-down problem solving

    [comp1110-0L]
    • July 30, 2026
    • Liam O'Connor, Fabian Muehlboeck

    Construction. Defining Functions

    [comp1110-0N]
    • Liam O'Connor

    As we have seen in Example [comp1110-0C], we can define functions in Java by stating their return type, then their name, then their parameters (types and names) in parentheses. The function body is surrounded by braces.

    int square(int x) { return (x * x); }

    When the return type is not void, we must include a return statement in the function body, which, when executed, will immediately cease execution of the function body and return the result to the caller.

    Definition. Top-down problem solving

    [comp1110-0M]
    • Liam O'Connor

    When employing top-down problem solving techniques, we assume we already have working implementations of functions to compute results for sub-problems, and use them to solve our main problem. Then, after we have implemented the main problem, we then tackle each sub-problem one by one. Sometimes it helps to apply this recursively: sub-problems get broken up into sub-sub-problems and so on.

    By contrast, bottom-up problem solving means we construct functions that we are likely to need, and only afterwards combine them to produce a solution to our problem. While this has the advantage of being easier to test, as we will have runnable code at every stage, it also carries the risk that we will waste effort designing, writing and testing functions that we do not actually need.

    Definition. The boolean type

    [comp1110-0P]
    • Liam O'Connor

    The type boolean is for values that may be either true or false. We can combine boolean values with the conjunction (&&) and disjunction (||) operators. The expression a && b is true exactly when both a and b are true. The expression a || b is true if at least one of a or b is true. We can also negate boolean values with the negation (!) operator. The guards of if statements and while loops are always expressions of type boolean.

    Construction. while loops

    [comp1110-0Q]
    • Liam O'Connor

    Loops are a way for control flow to repeat:

    int i = 0; while (i < 10) { IO.println("i < 10 is still true!"); i = i + 1; }

    The above code will print the message 10 times total, because in each iteration, the variable i (which starts at 0) is increased by one, until it reaches 10, when the loop will exit as the guard (i < 10) is false.

    Warning. Other forms of loops

    [comp1110-0R]
    • Liam O'Connor

    In your prior programming experience(s), you may have seen other kinds of loops, such as for or do loops. While we don't demonstrate these loops in our examples for the first part of this course, you are permitted to use them in your own work.

    In all cases, it is both possible and permissible to use while loops to solve looping problems.

    Example. Password Strength Checker

    [comp1110-0O]
    • Liam O'Connor, Fabian Muehlboeck

    It seems that every online service has a different bizarre set of requirements for passwords to be considered 'secure'. We came up with the following requirements in the lecture:

    1. Must be at least 10 characters long
    2. Every odd position should be an uppercase letter
    3. Must include "O_O"

    Surely any password that meets these requirements would be 'secure' indeed.

    We employ top-down problem solving here, defining first our main function in terms of currently unimplemented helper functions:

    boolean lenOK(String pwd) { return false; } boolean oddUppersOK(String pwd) { return false; } boolean smileyOK(String pwd) { return false; } void main() { String pwd = IO.readln("Enter password:"); boolean lenIsOk = lenOK(pwd); boolean uppercaseIsOk = oddUppersOK(pwd); boolean smileyIsOk = smileyOK(pwd); IO.println("lenOK = "+lenIsOk); IO.println("uppercaseOK = "+uppercaseIsOk); IO.println("smileyOK = "+smileyIsOk); }

    Currently our helper functions all return false because we have not yet implemented these checks, and it's a question of philosophy whether you want to make sure nothing passes that does not positively satisfy your criteria or nothing fails that does not positively violate them.

    Example.  lenOK

    [comp1110-0S]
    • Liam O'Connor, Fabian Muehlboeck

    To implement the length check for Example [comp1110-0O], we will get the length of the password given using the length() method for strings:

    boolean lenOK(String pwd) { return pwd.length() >= 10; }

    We use String method length here to determine the length of a given String.

    Warning. A common anti-pattern

    [comp1110-0T]
    • Liam O'Connor

    It's common for beginner programmers to use (sometimes multiple) if statements to achieve what can be achieved by simple boolean operators instead. For example, the following code can be greatly simplified:

    if (a) { if (b) { return true; } else { return false; } } else { return false; }

    Firstly, we can combine the if statements into one using boolean conjunction:

    if (a && b) { return true; } else { return false; }

    And, because we are simply returning the same value as the result of that boolean check a && b, we can elide the if statement completely:

    return (a && b);

    Example.  oddUppersOK

    [comp1110-0U]
    • Liam O'Connor, Fabian Muehlboeck

    To implement the odd-positioned uppercase character check for Example [comp1110-0O], we must loop through each odd-positioned character in the password. We discussed that while indices are 0-based, what we meant by odd positions are those whose 1-based indices are odd (i.e. 0-based indices 0, 2, 4, etc. count as "odd"). Then, we can start from index 0 and increase our pos variable by 2 every step. If any of the characters we encounter this way are not uppercase, we return false right away, which exits the loop immediately.

    boolean oddUppersOK(String pwd) { int pos = 0; while(pos < pwd.length()) { char ch = pwd.charAt(pos); if(Character.isUpperCase(ch)) { pos = pos + 2; } else { return false; } } return true; }
    bars magnifying-glass caret-down plus minus arrow-right xmark