You've never seen this before, but the general structure should be familiar.

The kind of loop that we are gonna introduce first is called the while loop

We'll use i as that variable just like we did in the while loop version.

We'll use i for that, and we start with 1 that's the first number to print out.

There's no requirement that guarantees the test expression eventually becomes False

The first one is a while loop with a nested if.

The result we want to return is the index where we found the match.

Then we're just going to keep repeating this until nothing changes.

We're going to keep multiplying by n until we get to the end.

How are we going to show that this is the case?

We could rewrite that using break.

Here are the four choices.

The second one is a while loop with the statement and a break.

The goal here is to countdown from n all the way down to blastoff.

I'll also show you a way to define it using a for loop.

The way we interpret JavaScript is by running it, and in the process of running it, we're never going to exit this Y loop because the condition is true.

When the break test is true, what we have is break whichà   by itselfà   is all we need.

When it is false or if it ever is false, we simply don't do anything which is exactly the same functionality we had with the while loop implementation.

A subroutine called countdown takes an input x.

So, here's my vector

You should remember the while loop from the previous unit.

So any problem you can solve either way.

So this one's going to require some thought, but you know enough to be able to do it.

The stopping condition for the while loop is when i reaches the len(p), so we want our test for the while loop to be i lt len(p).

So while tell you two ways to solve this the first is going to re use the Python while, and the second is going to implement the while loop recursively.

We'll use that as the index to go through the loop.

We're saying that's ab equals ab 0. Well, that's kind of obvious.

It starts out true but it remains true each time it goes through the while loop.

So we've seen 4 different ways to define the find_element method.

And when the call to get_next_target returns None for the URL, we know we're done.

When we start we have a depth of 0.

As described before, this is initially 2.

The third choice is a while loop with a nested if.

Let's leave the condition blank for now because we already know what we need to do inside the while loop, and that is, print the number.

So our test is using to compare e and t.

Again, if it's still true, then we evaluate the loop body, and we continue this process until the conditional expression is false, at which point we continue on after the while loop.

We'll define the loop to go through the elements of p, similarly to the previous while loops we've seen that go through lists.

We start by assigning zero to i

What we're going to do is define a procedure that will print all the links on the page, and it takes the page as input, and so we want to use a while loop to keep going, and I am going to leave blank the test condition for the while loop.

If I find an opening tag when it comes to the top of the while loop, it'll go through again.

So we still need to use a variable to keep track of the index.

We're going to increase i by 2, and then we're going to print i .

Here we have n n 1.

Evans There are many different ways we could solve this problem.

So this is a good question and in terms of being able to solve a problem, anything you can do with recursion you can also do with a 'while' loop.