ANA BELL: All right everyone, let’s get started. So good afternoon. So this is the 3rd lecture of 6.0001 and
600. As always, please download slides and code to follow along.

So a quick recap of what we did last time. Last time, we talked about strings as a new object
type, as sequences of characters. And then we introduced two new concepts that allowed us
to write slightly more complicated programs.

So we introduced branching, with these keywords, if, elif, else. And branching allowed us to
write programs that, us, as programmers, could introduce decisions into our programs. And
then we introduced two different kinds of loops, while loops and for loops. And those also
added a little bit of complexity to our programs.

Today, we’re going to talk a little bit more about strings. So we’re going to see a couple of
more operations that you can do on strings and string objects. And then we’re going to talk
about three different algorithms, a guess and check algorithm, an approximate solution
algorithm, and a bisection method algorithm.

So let’s dive right in. We’ll talk a little bit about strings, first. So strings, we thought of them as
sequences of characters, case sensitive, as we saw in programs we wrote last lecture. And
strings are objects. And we can do all of these operations on string objects, like test if they’re
equal, less than, greater than, and so on.

It turns out, we can do more than just concatenate two strings together or do these little tests
on them. So we’re going to start introducing the idea of a function or a procedure. And we’re
going to see more about functions and how you can write your own functions next lecture.
But for today, you can think of a function as sort of a procedure that does something for you.
Someone already wrote this. So the first one we’re going to look at is a pretty popular function.
And when applied on a string, this function, called len, will tell you the length of a string. So
that’s going to tell you how many characters are in the string. And characters are going to be
that’s going to tell you how many characters are in the string. And characters are going to be
letters, digits, special characters, spaces, and so on. So it’s just going to count how many
characters are in a string.

So if I have the string s is equal to “abc”– remember a string is in quotation marks– then, if I
do this, if I write this expression, len s, here, since it’s an expression, it has a value. So it
evaluates to a certain value. And by definition, it’s going to tell me what the length of the string,
which is 3 characters long.

Another thing that we can do on strings is, since they’re a sequence of characters, I might
want to get what character is at a certain position. So we do this using this fancy word called
indexing. But pretty much what indexing into a string means is you’re going to tell Python, I
want to know the character, at this certain position or at this certain index, inside my sting.

So once again, let’s use this string, s is equal to “abc.” And let’s index into it. So in computer
science, we start from 0, counting by convention. Notice, we had a problem set 0 in this class.
Python is no different.

So in Python, you start indexing at position 0. Or you start indexing at 0. So the first character,
in your string, we say is at position 0 or at index 0. The next character in the string is at index
1. And the next character in the string is at index 2.

In Python, it turns out, you can also use negative numbers to index. And if you index into the
string with negative 1, for example, that means that you want the last character in the string.
So the last character in your string is always going to be at position negative 1, the second-to-
last character is at negative 2, third-to-last character is at negative 3, and so on and so on.

So the way you index into a string is with these square brackets, here. And this is the notation.
So if I want the character at position 0 or at index 0, I say s, which is the string I want to index
into. And then, inside the square brackets, I say what index I want.

So s at index 0 is going to be the value “a.” s at index 1 is going to be the value “b,” and so on
and so on. And we can also do negative indexing, as well.

I added this in here. If you do try to index into a string beyond the limits of the string– and we
can even try this out, just to show you that it’s not the end of the world if we do that. If we have
s is equal to “abc,” and we have s at position 20, for example, obviously, my string is only
length 3, so what’s at position 20?

I get an error. I call this angry text, here, in Python. But really, the most relevant thing to note
is these last couple of lines here. This tells you what line is problematic. So s at position 20 has
an issue. And this last line here tells me what actual error I have. So it’s an index error, which
means I’m trying to index too far into the string, because it only has three characters.

So it’s nice to be able to get a single character out of my string. But sometimes, I might want to
get a substring. So I want to start at the first character and go halfway into the string, or I want
to take a few characters in between, or I want to skip every other letter or something like that
in my string.

So if I want to do this slightly more complicated interaction with strings, we call that slicing,
slicing into a string. And this notation here should seem a little bit familiar, because we saw it
last lecture when we did it with range.

We had a start, stop, and a step. The notation was a little bit different, because, in range, we
had open-close parentheses and commas in between. But except for that, this sort of works
the same.

The start is the index, starting from 0, from where you want to slice into this string. The stop is
the stop index. So you’re going to go up until stop minus 1 and take that index. And then the
step is how many letters you wish to take.

So this is the full notation here. But sometimes, you can not give it a third sort of number in
here. So if you only give it two numbers, then, to Python, that represents just the start and the
stop. And by default, step is going to be 1.

And there’s a lot of other things you can do with strings. You can omit numbers and just leave
colons in Python. By definition, the way that whoever wrote slicing had decided, if you omit
numbers, then it’s going to be equivalent to these things here.

So we slice using square brackets, just like indexing. Except now, we can give it two numbers.
So with this string, s, if we slice into the string s, we start from index 3 and go up until index 6.
So if we have abcdefgh, this is position 0, 1, 2, 3, 4, 5, 6, 7.

And you just count. So s, starting from 3 and going till 6, is going to start here, 3. So it’s going
to come up with– sorry d. And then we’re going to take e. And then we’re going to take f. And
since we’re going until stop minus 1, we’re not going to take g. Because this is position 6, and
we’re going until 6 minus 1.

The next one here, 3, 6, 2 is going every other one. So we start at 3, and then we skip every
other one, so we go d but not e, and then f, and then stop.

If you do s and then nothing inside except colons, notice that you’re going to have s, and then
nothing, and then colon, nothing, colon, nothing. So nothing for start, nothing for stop, nothing
for step. And that’s just going to value it to the string, itself. It’s the same as 0 to the length s
going every step.

This one might actually be useful. It reverses the string automatically for you. So with this one
little line here, you can get the inverse of your string. And that’s equivalent to that. So the
minus 1 represents starting from the end and going back every letter. And then this one’s a
little bit more complicated but also not too bad.

So as we’re doing these string slices, again, if you’re unsure what something does, just type it
into Spider. And you might be surprised. You might not be. But it’s a good way to check
yourself, to make sure you’re understanding what’s happening.

One thing I want to mention, and it’s good to keep this in the back of your mind. We’re going to
come back to this as we start talking about slightly more complicated object types. But strings
are immutable. So just keep this word in the back of your mind as we go through this class.
And what I mean by this is that an actual string object, once it’s created, cannot be modified.
This might not mean anything right now. But let me just draw a little something. Let’s say I
have this string, s is equal to hello.

Remember, in the first lecture, we drew a diagram sort of like this. This is my memory. I have
this object “hello.” And this object, “hello” is bound to this variable s. So now I can access the
object “hello” using this variable s.

Now you might think, well, since I could index into a string, I might be able to just say
something like, s at position 0 is equal to y. And that will just change the little h into a y, and I’ll
have a new object.

Well strings are immutable, which means, in Python, you’re not actually allowed to do this. And
it gives you an error if you do try to do that. If you want the variable s to point to the string, YE-
L-L-O, you could just say s is equal to Y-E-L-L-O.

Or you could do string operations like this. And this takes the y and it concatenates it to the
string s, all of the elements starting from position 1, which is e, l, l, o. So this makes Y-E-L-L-O.

Now internally, what happens when I write this line is Python says, OK, I’m going to break my
bond with this original object “hello.” I’m going to bind my string variable s to the new object
“yello.” and this other, old object still is in memory somewhere. But it’s an entirely different
object that I’ve created here.

Again, it might not mean anything right now, but just keep this in the back of your mind, strings
are immutable.

So the next thing I want to talk about is a little bit of recap on for loops. And we’re going to see
how we can apply for loops, very easily, to write very nice, readable code when dealing with
strings.

So remember that for loops had a loop variable. My loop variable being this var, here, in this
particular case. It can be anything you want. And this variable, in this particular case, iterates
over this sequence of numbers, 0, 1, 2, 3, 4.

So the very first time through the loop, var has a value of 0. It does the expressions in the
loop. As soon as they’re done, var takes the value 1. It does all the expressions in the loop.
And then var takes the value 2, and it does that all the way up until 0, 1, 2. And the last time it
goes around is with var is equal to 3.

And remember, we said that we can customize our range in order to start from a custom value
to end at a different value and to skip certain numbers.

So, so far, we’ve only been using for loops over a sequence of numbers. But actually, for loops
are a lot more powerful than that. You can use them to iterate over any sequence of values
not just numbers but also strings.

So here are two pieces of code, this one and this one here. These two pieces of code both do
the exact same thing. To me, possibly to you, this one looks a lot more readable than this one,
just at a first glance.

If I were to read this one, just using the keywords and variables here, it would sound like
broken English. But you could decipher what I’m trying to say. For a char in a string s, if the
char is equal to “i” or a char is equal to “u,” print “There is an i or a u.”

char is equal to “i” or a char is equal to “u,” print “There is an i or a u.”

It sounds weird, but you could probably tell what I was trying to do here. Whereas up here, it’s
a little more complicated to tell what I’m doing. You have to sort of think about it a little bit.

For some index in this range of numbers, 0 through the length of the string s, if s, at position
index, is an “i” or s at position index is a “u” print, “There is an i or a u.” Both of these codes
just go through the string s. And if it encounters a letter that’s an i or a u, it’s just going to print
out this string here.

But this bottom one is a lot more pythonic. It’s an actual word created by the Python
community. And it just looks pretty, right? You can tell what this code’s supposed to do.
Whereas this one is a little bit harder to decipher.

So that’s sort of an illustration of a for loop over a sequence of characters. So char is going to
be a loop variable, still. And the loop variable, instead of iterating over a set of numbers, it’s
going to iterate over every character in s, directly. And char is going to be a character. It’s
going to be a letter.

So here’s a more complicated example. I wrote this code a couple of years ago. And it was my
attempt at creating robot cheerleaders , because I needed some motivation. And then I
googled, last night, “robot cheerleaders,” and was not disappointed. Created this GIF. It looks
pretty cool. And it looks like they kind of stole my idea. But that’s fine.

So let’s look at what this code’s supposed to do. I’m going to run it. I’m going to run it, and
then we’ll go through it. All right, it prints out, “I will cheer for you! Enter a word.”

You know what, I like robots, so I’ll put in “ROBOTS.” How enthusiastic am I about robots?
Let’s say 6. So what this is going to print is– it’s a cheerleader, right? “Give me an r, r.” “Give
me an o, o.” “Give me a b, b,” and so on and so on.

“What does that spell? ROBOTS.” And it’s going to print it 6 times, because I’m 6 out of 10
enthusiastic about robots. So that’s pretty much what that code’s supposed to do. And you can
write it using what we’ve learned so far.

Now let’s go through it a little bit. And I’m going to show you just how easy it is to convert this
code using a for loop over characters. Right now, what it does is it asks the user for input, so a
word and a number.

And then it does this thing, here, right? First, it uses a while loop. And second, it uses indexing.
And what tips you off that it’s using indexing is it’s using the square bracket, here, into the
word.

And obviously, it’s using a while loop. And it has to first create a counter, initialize it. And then,
down here, it’s going to increment it inside the while loop. If you remember, that’s sort of what
we need to do for while loops.

So it’s going to start at 0, and it’s just basically going to go through index i is equal to 0, 1, 2, 3
4, which is going to go all the way to the end of the word, whatever the user typed in, in this
case “ROBOTS.” It’s going to get the character at that position. word at position i is going to be
a character.

This line here is just for the cheerleading to make sense. It’s just to take care of letters that
make sense to use an, right? So give me a b, give me an b. So give me an b does not make
sense, right? So that’s just taking care of that.

And I’m using this in keyword to check whether the character– so the character, r, for
example, in robots– is inside an letters. And an letters I’ve defined up here, which is these are
all the letters that make sense to put an an before the letter. So give me an r for example,
here, on the right.

And so if it makes sense to use an before the letter, use that, and otherwise use just an a. And
after I’m done, I say, “What does that spell?” And then it’s just a for loop that goes times many
times and prints out the word and the exclamation mark.

So this code might have been a little bit more intuitive if I rewrote it or if I’d originally written it
with a for loop. So this part here, the while loop and indexing and creating my original counter,
we can get rid of that.

And we can replace it with this, for char in word. I’m originally using char, so I can use char as
my loop variable again. And simply, I’m just going to iterate over the word, itself.

So now, instead of having this mess here, I have a one-liner that says, for every character in
my word, do all this stuff here. So that remains the same. And then I don’t even need to
increment a counter variable, because I’m not using while loops anymore. I’m just using a for
loop.

So the code becomes– delete that– for char in word. And then delete that. And that does the
exact same thing. And it’s a lot more readable.

So this was our toolbox at the beginning of this course. We are two and half, I guess, lectures
in. These are the things we’ve added to it. We know integer, floats, Booleans. We know a bit of
string manipulation, math operations. We added, recently, these conditionals and branching to
write slightly more interesting programs.

And now we have loops, for and while loops to add interesting and more complicated
programs. So with these, the second part of this lecture is going to be looking at three different
algorithms. That’s the sort of computer science part of this class, Introduction to Computer
Science and Programming using Python.

Don’t let the word algorithm scare you. They’re not that complicated. You just have to sort of
think a little bit about them. And you’ll be able to get them.

So we’re going to look at three algorithms, all in the context of solving one problem, which is
finding the cube root. The first algorithm is guess and check, then we’re going to look at an
approximation algorithm, and then a bisection search.

So the first is the guess and check method. You might have done this, in math, in high school.
The guess and check method is also sometimes called exhaustive enumeration. And you’ll see
why.

So given a problem, let’s say, find the cube root of a number, let’s say you can guess a
starting value for a solution. The guess and check method works if you’re able to check if your
solution is correct.

So if your guess is originally 0, you can say, is 0 cubed equal to the cube of whatever I’m
trying to find the cube root of? So if I’m trying to find the cube root of 8, is 0 cubed equal to 8?
No. So the solution is not correct.

If it’s not correct, guess another value. Do it systematically until you find a solution or you’ve
guessed all the possible values, you’ve exhausted all of your search space.

So here’s a very simple guess and check code that finds the cube root of a number. So I’m
trying to find the cube root of 8. So my cube is 8. I’m going to have a for loop that says, I’m
going to start from 0. And I’m going to go all the way up to–

So I’m going to start from 0 and go all the way up to 8. For every one of these numbers, I’m
going to say, is my guess to the power of 3 equal to the cube 8? And if it is, I’m going to print
out this message.

Pretty simple, however, this code is not very user friendly, right? If the user wants to find the
cube root of 9, they’re not going to get any output, because we never print anything in the
case of the guess not being a perfect cube. or the cube not being a perfect cube.

So we can modify the code a little bit to add two extra features. The first is we’re going to be
able to deal with negative cubes, which is kind of cool.

And the second is we’re going to tell the user, if the cube is not a perfect cube, hey, this cube
is not a perfect cube. So we’re not going to silently just fail, because then the user has some
sort of feedback on their input.

So let’s step through this code. We have, first of all, a for loop just like before. And we’re going
to go through 0 to 8 in this case. We’re using the absolute value, because we might want to
find the cube root of negative numbers.

First thing we’re doing is doing this check here. Instead of guessing whether the guess to the
power of 3 is equal to the cube, we’re going to check if it’s greater or equal to, and we’re going
to do that for the following reason.

So if we’re trying to find the cube root of 8, for example, versus a cube root of 9– this is 8 and
this is 9– what is this code going to do? It’s going to first guess 0. 0 cubed is not greater or
equal to 8. 1 cubed is not greater or equal to 8.

2 cubed is greater or equal to 8, so here, once we’ve guessed 2, we’re going to break.
Because we found a number that works. And there’s no need to keep looking. Once we’ve
found the cubed root of this number 8, there’s no need to keep searching the remainder, 3, 4,
5, 6, 7, 8.

Sort of the same idea when we’re trying to find the cube root of 9. We’re going to start with 0.
0 to the power of 3 is less than 9. 1 to the power of 3 is less 9. 2 to the power of 3 is less than
9.

When we get to 3 to the power of 3, that’s going to be greater than 9. So this code tells us,
once we’ve picked a number that’s beyond the reasonable number of our cubed root, of our
once we’ve picked a number that’s beyond the reasonable number of our cubed root, of our
cube, the cubed root of our cube, then we should stop.

Because, again, it doesn’t make sense to keep searching. Because if 3 to the power of 3 is
already greater than 9, 4 to the power of 3 is also going to be greater than 9 and so on. So
once we break here, we either have guess being 2 or guess being 3 depending on what cube
we’re trying to find.

And if the guess to the power or 3 is not equal to the cube, then, obviously, the cube was not a
perfect cube. So that’s this case here, if we were looking at at the cube root of 9. And
otherwise, this part here just looks at whether we should make it a positive or a negative cube.
So if our original cube was less than 0, then, obviously, the cube root of a negative number is
going to be a negative number, and, otherwise, it’s just our guess.

So that’s the guess and check method, slightly more feature-rich program for guessing the
cube root. But that only tells us the cube root of perfect cubes and doesn’t really give us
anything else, any more information.

So sometimes, you might want to say, well, I don’t care that 9 is not a perfect cube, just give
me a close enough answer. So that’s where approximate solutions come in. So this is where
we’re OK with having a good enough solution.

So in order to do that, we’re going to start with a guess and then increment that guess by
some small value. Start from 0 and start incrementing by 0.001 and just go upwards from
there. And at some point, you might find a good enough solution.

In this program, we’re going to keep guessing as long as we’re not close enough. And close
enough is going to be given by this epsilon value in the program. So as long as the guess
cubed minus the cube– so how far away are we from the actual answer– is greater than some
epsilon, keep guessing, because the solution is not good enough.

But once this is less than epsilon, then we’ve reached a good enough solution. So two things
to note with approximate solutions. So you can get more accurate answers if your step size is
really, really small. If you’re incrementing by 0.0001, you’re going to get a really good
approximate solution, but your program will be a lot slower.

Same sort of idea with epsilon, you can change epsilon. If you change epsilon to be a bigger
epsilon, you’re sacrificing accuracy, but you’re going to reach a solution a lot faster.

So here’s the code for the approximate solution of a cube root. It might look intimidating, but,
look, almost half this code is just initializing variables. So we’re initializing, this is the cube we
want to find the cube root of. We pick an epsilon of this. We start with a guess of 0. We start
with an increment of 0.0001. And just for fun, let’s keep track of the number of guesses that it
takes us to get to the answer.

This is similar to the guess and check from before. It’s not similar. Well this part is similar to
the guess and check from before. So we’re going to take the guess to the power of 3 minus
the cube, right? So that’s how far away are we from the actual answer?

And we’re going to say, if that’s not good enough– so if we’re still greater than or equal to the
epsilon– then keep guessing. So we’re going to be stuck in this loop, where we keep guessing
values, until we’ve reached a guess that’s good enough, so until we’re less than epsilon.

And way we keep guessing is just with this line, right here, which says, increment my guess by
increment, and increment being this really small value. That make sense?

So I’m going to keep incrementing my guess by that small value. Before I go on, I’m going to
run the code. And we’re going to discover a small issue with it.

So with 27, we’re going to run it. Perfect, it took me 300 guesses. But 2.99999 is close to the
cube root of 27. We can find the cube root of this guy here. And it took me 20,000 guesses,
but I figured out that 200.99999, so 201, is close to the cube root of that large number.

I should have done this. This is going to be a giveaway, you guys. Sorry. Then we’re going to
have– let’s say I want to try cube of 10,000. So 10,000 is not a perfect cube. So we can run
the code. And with 8,120,601 I had already gotten an answer. But with 10,000, I’m not getting
an answer yet, right?

So I’m thinking that there might be something wrong. So I’m going to stop my code. So I just
hit Control C, because I feel like I’ve entered an infinite loop. And, in fact, I have. So what
ended up happening is this problem here.

So I’m going to draw something. According to the code, I’m going to start from 0, and I’m
going to increment my guesses, like that. With every little increment, I’m going to make a new
guess. I’m going to take that guess to the power of 3. I’m going to subtract the cube, and I’m
going to figure out if I’m less than epsilon.

This is the epsilon that I want to be in, this little bit here. So with every new guess, I might be,
maybe– so this is where I want to be, within this little boundary here. With every new guess, I
might be here.

With the next guess, over here, I might be here. When I make another guess, I might be here.
So I’m getting close to being within epsilon. But maybe with my next guess, I’m going to hop
over my epsilon and have made too big of a guess.

So just because of the way the numbers were chosen in this example, just to illustrate this,
using an increment of 0.01, a with finding the cube of 10,000 and epsilon of 0.1, it turns out
that, as I’m doing all these calculations, I’m going to skip over this perfect sort of epsilon
difference.

So first, I’m going to be too small. And then I’m going to be too large. And once I’ve become
too large or too far away from epsilon, the guesses I continue to make are just going to be
even farther away from epsilon. And I’m not going to get to my answer.

And that’s why I’ve reached an infinite loop in this code. All I’m doing in this code is checking
whether my guess cube minus cube is less than epsilon. The only thing I need to do here is
sort of add this little clause, here, that says, oh, by the way, also check that I’m less than cube.
Because this is just like we did in the very first program, when I’m checking 0, 1, 2, 3, 4, 5, 6,
7, 8, when I’m trying to find the cube root of 8. Once I’ve reached 8, I’m going to stop. And it’s
the same thing here.

So I just added this little clause that says, well, while I’m greater than or equal to epsilon and
I’m still less than the actual cube, just keep searching. But once I’ve reached the cube, then
stop searching.

And with 10,000, you can see that I failed to actually find– so that’s what this part, here, does.
It tells me I’ve failed to find the cube root with those particular parameters.

The last thing we’re going to look at is bisection search. And to illustrate this, I’m going to need
one volunteer. And you’re going to play a game with me in front of the whole class. And there
will be a prize. There go the hands. In the blue shirt, right there. Cool.

So the prize is going to be, once again, this. I promise I don’t have millions of these, Google
glasses. I also don’t work for Google. I just happened to get a couple.

So the game is this. I’m going to ask you to pick a number, a whole number, between 0 and
100. And I’m going to try to guess it. And you need to make it hard for me. And you need to
make it so hard for me that I cannot guess it within 10 guesses.

And if you can do that, if I cannot guess it within 10 guesses, you get this. And I’m going to
draw out what I do as we go along. So do you have your number? Yes?

AUDIENCE: Yeah.

ANA BELL: Perfect. Let me erase that. Actually, I should’ve probably kept that, because I’ll still use it.
There’s the numbers, 0 to 100. Is your number 50?

AUDIENCE: No.

ANA BELL: 50 Was my guess. So I’ve made one guess. Is your number higher or lower than 50?

AUDIENCE: Higher.

ANA BELL: Higher. Is your number– my next guess is going to be 75. And the reason I’m guessing 75 is
because– what’s your name?

AUDIENCE: Sophie.

ANA BELL: What’s that?

AUDIENCE: Sophie.

ANA BELL: Sophie. Sophie said, 50 was too low. So I immediately know that it cannot be any less than 50.
So I’ve already eliminated half of the numbers. So my next guess is 75. Is your number 75? Is
your number lower or higher?

AUDIENCE: Higher.

ANA BELL: Since it’s higher, I’m eliminating this half here. Is your number– so between 75 and 100. Oh,
boy, you’re putting me on the spot. What’s that?

AUDIENCE: 87.

ANA BELL: 87, thank you. 87?

AUDIENCE: No.

ANA BELL: Higher or lower?

AUDIENCE: Lower.

ANA BELL: Lower. So since it’s lower, I’m eliminating that half. Is your number 81? Higher or lower?

AUDIENCE: Lower.

ANA BELL: So she said, lower, so I’m eliminating that half. Is your number 78? Oh, boy, that’s really hard.
78, OK. Higher or lower?

AUDIENCE: Lower.

ANA BELL: Is your number 76?

AUDIENCE: Yeah.

ANA BELL: Yay. All right, perfect, 76 was the number. So how many guesses have I made? One, two,
three, four, five, six– I made six guesses. So I did get it under 10. But you know what? The
game was rigged. So you get the prize anyway, just because I rigged the game. Here you go.
Pass it down.

AUDIENCE: Thank you.

ANA BELL: Thank you. So notice, in bisection search, what I did was I eliminated half the search space
with every guess. I said, well, she said it’s higher or lower, so I definitely cannot be in the other
search space, right? If I was doing approximate solution or, in this case, guess and check, I
would be asking Sophie, is your number 0, 1, 2, 3, 4, and so on?

So with guess and check, it would have taken me 76 guesses to get to the number, whereas,
with this bisection search, that I just did, it only took me 6. Isn’t that cool?

So that means that the larger the space actually is, that I need to search, the better it is to use
bisection search, this bisection search method. So that’s basically what I’m illustrating here. So
we have our original search space. We’re going to choose a guess halfway, eliminate half of
the guesses. Then we’re going look in the remaining interval, eliminate half the guesses, and
so on and so on.

So then this is the code for bisection search. Also looks intimidating, but it’s not so bad. So
we’re initializing a bunch of stuff up here. The most important couple of things we’re initializing
are, first of all, this high and this low boundaries.

So with the guessing game, the low boundary was 0, and the high boundary was 100. When
we’re looking at the cube root, the low boundary is going to be 0, and the high boundary is
going to be just my cube, because a guess to the power of 3 cannot be any greater than cube.

And then, I’m just going to do the same procedure that I did with the guessing game, which is
I’m going to make my guess, be halfway in between. So with this guessing game, I had to sort
of choose, if there were four numbers in between, should I go higher or lower?

Well, when we’re doing by bisection search, here, we don’t care about that. We’re just going to
do floating point division, because we want decimal numbers. So I have a low boundary and a
high boundary. And I figured out my halfway point.

Then I have this while loop here. A while loop is similar to the approximation method, where,
as long as I don’t have a guest that’s good enough– so this, depicted by this greater or equal
to epsilon– as long as my guess is not good enough, I’m going to keep guessing. That’s what
this while loop is saying.

So if the guess to the power of 3 minus cube is not good enough, keep guessing. And the way
I keep guessing is this part, here, says, my guess was too low. So if my guess was too low, set
the low boundary to be the guess. Because I don’t care about all of the other numbers that are
much lower than me.

So set the low to be the guess. That’s what that line is doing. And otherwise, my guess was
too high. That’s what this else is doing. So set the high to be the guess, because I don’t care
about numbers any higher than my guess.

Once I have these new boundaries, I make another guess, again, halfway in between the new
boundary points. So essentially, I’m just halving my interval with every single guess. And that’s
what the while loop is doing. And then I print out the remaining part.

So notice the search space originally being N, we’re halving it with each guess. So the first
guess divides it by 2, the second guess divides it by 4, and so on. So by the time we get to the
k-th guess, N/2k, the k-th guess, let’s say that’s the actual answer we’re interested in. There’s
only one value in that little interval. And that’s the answer we want.

So 2 to the k is equal to N. And then how many guesses did we make? k is equal to log base 2
of N. So when we are playing the guessing game of 100, my end was 100. Log base 2 of 100
is 6.-something, I think.

So in fact, I could have said, if I don’t guess it within seven guesses, you would have won as
well. So that’s why the game was rigged. So the guess, notice, it converges on the order of log
base N instead of just linearly in terms of N. So that’s why it’s so powerful.

One last thing I want to mention is the code I showed only works for positive cubes. And that’s
because of the following. So I have this 0 and 1. Let’s say I’m trying to find the cube root of
0.5.

When I first set my initial boundaries, my low is this one, and my high is this one. But what’s
the cube root of 0.5? Is it within this boundary or is it outside this boundary?

AUDIENCE: Outside the boundary.

ANA BELL: I heard, outside. It’s like 0.7 something. So it’s out here. So with this particular code, I’m going
to be halving my interval in between those numbers, but I’ll never get to an answer. Because
the actual cube root of 0.5, or numbers less than 1, is going to be outside that boundary.

So there’s a small change you can make to the program, which will fix that. And that’s in the
code. I didn’t put it in, but it’s a very small change, a small if statement. So that’s it. All right,
thank you.

[APPLAUSE]