In this lesson, we’ll pause to reinforce what we’ve learned about the basic building blocks of computer science: storing data, making decisions, and repeating operations. We’ll also get some more practice with loops!
Let’s warm up with a bit of debugging practice.
We've learned how to use computers to manipulate numeric data and make simple decisions using conditionals. But we haven't examined one of their most important capabilities: the ability to repeat the same task over, and over, and over again. A computer will never get tired—although it may run out of battery—and it will never make a mistake—as long as you program it correctly. So this capability is the grounds for our hope that someday computers may help eliminate many current forms of drudgery currently experienced by humans, particularly when forced to repeat mindless tasks.
Let's get started by writing using a simple loop. Assuming an
Int variable named
repeat has been declared and
initialized to a value larger than or equal to zero, write a loop that prints "Victory!"
repeat times on separate
lines. You may use any kind of loop you want! But do not modify the value of
Last time we discussed how we can exit a loop early using the
break causes the enclosing loop—either
for—to immediately exit, regardless of whether the loop condition is true or not.
continue is another control statement that we can use inside a loop.
Let’s explore how it works together!
break causes the loop to exit,
continue causes the code to return to the top of the loop immediately, check the loop condition, and then continue if appropriate.
continue is used less frequently than
One of the reasons is that, we can always rewrite any loop that uses
continue to instead use an
Let’s see how:
What’s more clear:
continue versus an
It really depends on the problem.
If the loop body is long and complicated, it can be better to use
continue at the beginning to avoid values that shouldn’t be considered by the rest of the loop.
continue can make your code hard to read.
So for shorter loops, it’s usually better to just put the entire loop body inside an
if statement instead.
array that is already declared and initialized, write a snippet of code
(not a method), that prints a line with the sum of the values in
array that are even.
To get some additional practice, let’s work through an example together that is similar to this lesson’s homework. It also provides us a chance to practice with a very common array and loop programming pattern.
Given an array of values, how would we count the number of values that have some property? For example, let’s say that we need to count the number of values which are greater than zero.
Let’s work step-by-step. First, let’s outline what we need to do.
Next, let’s get our loop set up! It’s always a good idea to make sure that we can actually access all of the values in the array before doing anything more complicated.
As the third step, let’s review how we determine if a value is greater than zero, and integrate that into what we have so far.
Finally, let’s examine the design pattern that emerges from this example: a combination of iteration (our
for loop) and selection (our
By combining these two and using different conditions and data, we can solve a lot of different problems!
We can also combine results in different ways as well.
Before we wrap up, let’s review one useful bit of Kotlin that we’ll use regularly during some of our upcoming examples: How to test whether a value is even or odd.
array that is previously declared and initialized, write a snippet of code
(not a method), that prints a line with the count of the number of values in
array that are odd.
Need more practice? Head over to the practice page.