Loops: Lesson

Now that we’ve written a `while` loop, let’s write an alternate form of it.

We’ll look at its syntax first then explain what’s happening and why:

```c
do {
  // Statement(s)
} while (condition);
```

This is odd, the condition came _after_ the statements. Does this mean the condition isn’t checked until _after_ the statements get executed?

That is exactly what happens!

This is what’s known as a `do-while` loop. Simply put, it _does_ something first, and then checks the condition afterward and loops in this manner until the condition is no longer `true`.

The `do-while` loop is most often used when a program wants to do something at least once before checking the condition.

do-while Loop

A _loop_ is a way to _repeat_ code or a set of instructions until a specified condition is reached.

For example, have you ever been looking for somebody in a grocery store? You check each aisle until you find them. You naturally perform certain tasks with a repetition, or _iteration_, until a condition is met. In this case, when you finally catch that glimpse of a familiar person!

That generic term "iterate" means "to repeat." You’ll find that, just like in real life, you’ll use loops in your code all the time! And just like this infinite GIF of blocks turning, a task may repeat seemingly infinitely, but you always have a way to control when it stops.

When we see that a process has to be repeated multiple times in a row, we write a loop. Loops allow us to create efficient code that automates processes to make scalable, manageable programs.

In this lesson, we will learn about three types of loops: `while` loops, `do-while` loops, and `for` loops!

Introduction to Loops

In a video game, a "Game Over" screen often allows you to "continue" from a previous save or checkpoint. Loops can do this in much the same way using `continue`, the second keyword we’ll learn this lesson!

In a loop, if a `continue` is ever reached, it will immediately skip the rest of the statements inside the loop body and "continue" into the next iteration.

For example, let’s look at the following syntax:

```c
for (int i = 0; i < 10; i++) {
  if (i % 2 == 0) {
    continue;
  }
  printf("%d is odd\n", i);
}
```

Inside the `for` loop, we see an `if` statement checking if the current counter, `i`, is an even number by using the `%` operator. If `i` is even, `continue` to the next iteration and _skip_ the print statement below. If `i` is odd, print `i` and continue as normal.

**Note:** These keywords can still affect a loop even if they’re contained inside an `if` statement. This means a `continue` will always advance to the next iteration even if it’s nested in multiple `if / else` statements! This goes for other loop keywords as well, like `break`. If there are nested loops, a keyword will only interact with the most interior loop it is contained in.

Continuing

Before we dive deep into the syntax of a loop, let’s do a demo!

We have a program that asks and checks for a pin. It uses a `while` loop, which will be the first type of loop we’ll learn about, to ask the user to type and enter a pin over and over again until the correct one is entered.

As a reminder, here's how to compile and execute your code:

```
gcc enter_pin.c
./a.out
```

**Note:** You don’t need to understand the code yet, just how to interact with it!

Interacting with a Loop

Great job! You completed the lesson on loops! 🙌

Key concepts covered in this lesson:
- Loops perform repetitive actions so we don’t have to code those actions manually every time.
- How to write `while` loops with a condition.
- How to write `do-while` loops with a condition.
- How to write `for` loops with a counter that increments or decrements.
- How to `break` out of a loop.
- How to `continue` a loop at any point.

Review

For the last loop we held your hand, so let’s try one on your own!

As an example of iteration, we have the first program ever to run on a stored-program computer (the [EDSAC](https://en.wikipedia.org/wiki/EDSAC)). It was written and run by David Wheeler in the computer laboratory at Cambridge University, England, on May 6th, 1948, to calculate and print a simple list of squares like the following:

```
0	0
1	1
2	4
3	9
4	16
5	25
6	36
7	49
8	64
9	81
```

On the left, there are numbers from 0 to 9. On the right are their squares. For example, for the number 9: 9 * 9 = 81.

**Note:** An algorithm like this is one of the easiest tells for needing a loop. But as you develop your programming skills, you’ll pick up more and more subtle hints and uses for where loops can be incorporated into your code!

while Loop

Now that you’ve interacted with a loop, let’s write one!

The `while` loop looks very similar to an `if` statement. And just like an `if` statement, it executes the code inside of it _if_ the condition is `true`. The difference, however, is that the `while` loop will continue to execute the code inside of it, _over and over again_, as long as the condition is `true`.

Here’s a simple form of the `while` loop:

```c
while (condition) {
  // Statement(s)
}
```

In other words, instead of executing _if_ something is true, it executes _while_ that thing is true.

```c
while (guess != 8) {
  printf("Wrong guess, try again: ");
  scanf("%d", &guess);
}
```

In this example, the program will keep asking the user to input a new number while `guess` is not equal to 8. It will exit the `while` loop once the user types `8`, allowing the condition to finally become `false` and let the program continue.

Guess the Number

The `while` loop examples we’ve looked at so far iterate over a sequence of numbers. This is so common that C, like most other programming languages, has a special syntax for it.

When we know exactly how many times we want to iterate (or _count_), we can use a `for` loop instead of a `while` loop.

For example, this is a `for` loop:

```c
for (int i = 0; i < 10; i++) {
  printf("%d\n", i);
}
```

Let’s take a closer look at the first line:

```c
for (int i = 0; i < 10; i++)
```

There are three parts to this separated by two `;`:
- The initialization of a _counter_: `int i = 0`
- The condition: `i < 10`
- The change in the counter (in this case an increment): `i++`

In the first part, we create a variable `i` that starts from 0 and acts as our counter. In the second part, as long as our counter `i` is less than 10, the statements within the loop will repeatedly run. In the third and final part, after each iteration of the `for` loop, we add 1 to `i` using the `++` operator.

Or in other words, we start with some initialized variable, then _while_ some condition is true, we do something, then we incrementally change the control variable. Does this sound familiar?

It’s just like a `while` loop! In fact, the above `for` loop does the exact same thing as the `while` loop we just worked with in the previous exercise!

The `while` loop from exercise 5:

```c
int i = 0;

while (i < 10) {
  printf("%d\n", i);
  i++;
}
```

**Note:** This distinction is important because it allows us to switch between `while` loops and `for` loops to best fit the current program’s needs. If we don’t quite know when a loop may end, we use a `while` loop. If we _do_ know exactly when a loop should end, we use a `for` loop.

for Loop

When working with loops, it’s important to know a few special keywords that can affect how a loop runs. Let’s look at a quick example to introduce the first special keyword!

Do you remember the `while` loop from exercise 3?

```c
while (guess != 8 && tries < 50) {
  printf("Wrong guess, try again: ");
  scanf("%d", &guess);
  tries++;
}
```

The loop runs until `8` is guessed or 50 attempts have been made to guess the secret number. This means the loop will stop running as soon as one of those conditions is met. There is another way to write this, but using a special keyword. See if you can spot it!

```c
while (tries < 50) {
  scanf("%d", &guess);

  if (guess == 8) {
    break;
  }

  printf("Wrong guess, try again: ");
  tries++;
}
```

The keyword `break` allows us to, quite literally, "break" out of a loop and stop it from running any more times. 

It can often simply be avoided with careful planning of the conditional controlling a loop. It’s generally advised to be careful with breaking out of loops because it can result in unexpected processing when a programmer has a mental plan centered around a loop finishing all its iterations.

However, when used effectively, a `break` can increase the efficiency of a program and help minimize its memory uses through unnecessary variables.

**Note:** `break` is most often used when a program wants to run a loop infinitely in a controlled manner. For example, a program that runs until the user types "quit." In that instance, the program may run forever, but will only break out of its running loop when the user tells it.