
Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 오픈 콘텐츠가 저작권을 적용하여 
제공되고 있습니다. 
여러분의 지원이 MIT OpenCourseWare가 계속해서  
높은 품질의 교육 자료를 무료로 제공할 수 있게 합니다.
또 다른 MIT의 수업을 시청하고
싶으시면 MIT OpenCourseWare 로 
방문해 주세요..
지난 시간에, 우리는 이 태그 레슬링 팀 같은 것을 하며 끝냈습니다, 
구탁 교수가 첫 번째 절반을 하고,
제가 강의의 두 번째 절반을 했습니다, 
그리고 강의의 두 번째 절반은, 우리가 복잡도에 대하여 이야기를 하기 시작 했던 것 입니다. 
그것은 효율성 입니다. 
증가의 순서 라고도 합니다. 
그리고 그것은 우리가 오늘 하려고 하는 것 입니다, 
그것은 그 주제에 대해 이야기 하는 것 입니다. 
저는 그것을 다음 몇 강의들 내내 
하려고 합니다.
저는 여러분에게 우리가 복잡도에 대해 꽤 높은 수준에서 이야기 했던 것을 
상기 시켜 드리고 싶습니다. 
우리는 곧 여기서 자세히 들어 갈 것 입니다. 
그러나 우리가 강조 하려고 하는 것은  
그것은 중요한 설계 결정 이라는 것 입니다, 
우리가 코드를 가지고 할 때요, 여러분의 코드가 가지는 효율성에 대해서요.
그리고 우리가 이야기 했던 두 번째 것은 

English: 
ANNOUNCER: Open content is
provided under a creative
commons license.
Your support will help MIT
OpenCourseWare continue to
offer high-quality educational
resources for free.
To make a donation, or view
additional materials from
hundreds of MIT courses, visit
MIT OpenCourseWare at
ocw.mit.edu .
PROFESSOR ERIC GRIMSON: Last
time, we ended up, we sort of
did this tag team thing,
Professor Guttag did the first
half, I did the second half of
the lecture, and the second
half of the lecture, we
started talking about
complexity.
Efficiency.
Orders of growth.
And that's what we're going to
spend today on, is talking
about that topic.
I'm going to use it
to build over the
next couple of lectures.
I want to remind you that we
were talking at a fairly high
level about complexity.
We're going to get down into
the weeds in a second here.
But the things we were trying
to stress were that it's an
important design decision, when
you are coming up with a
piece of code, as to what kind
of efficiency your code has.
And the second thing that we
talked about is this idea that

English: 
we want you to in fact learn
how to relate a choice you
make about a piece of
code to what the
efficiency is going to be.
So in fact, over the next thirty
or forty minutes, we're
going to show you a set of
examples of sort of canonical
algorithms, and the different
classes of complexity.
Because one of the things that
you want to do as a good
designer is to basically
map a new problem
into a known domain.
You want to take a new problem
and say, what does
this most look like?
What is the class of algorithm
that's-- that probably applies
to this, and how do I pull
something out of that, if you
like, a briefcase of possible
algorithms to solve?
All right, having said that,
let's do some examples.
I'm going to show you a sequence
of algorithms,
they're mostly simple
algorithms, that's OK.
But I want you to take away from
this how we reason about
the complexity of these
algorithms. And I'll remind
you, we said we're going to
mostly talk about time.
We're going to be counting the
number of basic steps it takes
to solve the problem.
So here's the first example
I want to do.
I'm going to write a function
to compute integer power

Korean: 
우리가 여러분에게 사실 여러분이 만든 코드를 효율성이 무엇이 되는지 와 
연관 시키는 방법을 배우도록 하려는 생각 입니다.
그래서 사실, 다음 30 분 또는 40 분에 걸쳐, 
우리는 여러분에게 고전적인 알고리즘들의 몇 가지 예들과 
복잡도의 다른 단계에 대해 보여 주려고 합니다.
왜냐하면 여러분이 좋은 설계자로서 하길 원하는 것들 중 
하나는 기본적으로 새로운 문제를 알려진 
도메인으로 만드는 것 이기 때문 입니다. 
여러분은 새로운 문제를 가지고 말하길 원합니다, 
이것이 대부분 무엇과 같은가? 
알고리즘의 단계는 – 그것은 아마 이것에 적용 합니다, 
그리고 제가 그것을 거기에서 어떻게 떼어 낼 수 있나요, 
여러분이 좋아 한다면, 풀어야 하는 가능한 알고리즘의 서류 가방으로부터 어떻게 떼어 내나요?
좋아요, 그것에 대해 말하기 위해, 몇 가지 예를 해 봅시다. 
저는 여러분에게 알고리즘의 순서를 보여 주려고 합니다, 
그것들을 대부분 간단한 알고리즘 입니다, 그것은 괜찮습니다. 
그러나 저는 여러분이 우리가 이 알고리즘의 복잡도에 대해 
어떻게 사고 하는지를 이것으로부터 가져오도록 했으면 합니다.
그리고 저는 여러분에게 상기 시켜 드릴 것 입니다,
우리는 우리가 대부분 시간에 대해 이야기 할 것 이라고 말했습니다. 
우리는 문제를 푸는데 걸리는 
기본적인 단계의 수를 셀 것 입니다.
그래서 여기 제가 하려고 하는 첫 번째 예가 있습니다. 
저는 정수의 지수를 계산하는 함수를 쓸 것 입니다.

English: 
exponents. a to the b where
b is an integer.
And I'm going to do it only
using multiplication and
addition and some simple tests.
All right?
And yeah, I know it comes built
in, that's OK, what we
want to do is use it as an
example to look at it.
So I'm going to build something
that's going to do
iterative exponentiation.
OK?
And in fact, if you look at the
code up here, and it's on
your handout, the very first
one, x 1, right here-- if I
could ask you to look at it--
is a piece of code to do it.
And I'm less interested in the
code than how we're going to
analyze it, but let's look
at it for a second.
All right, you can see that
this little piece of code,
it's got a loop in there,
and what's it doing?
It's basically cycling
through the loop,
multiplying by a each time.
So first time through the
loop, the answer is 1.
Second time it-- sorry, as it
enters the loop, at the time
it enter-- exits,
the answer is a.
Next time through the loop
it goes to a squared.
Next time through the loop
it goes to a cubed.

Korean: 
a b 에서 b 가 정수 입니다. 
그리고 저는 그것을 곱셈과 덧셈 만을 사용해서 할 것 이고 
몇 가지 간단한 테스트를 해 볼 것 입니다. 
알겠죠? 
그리고 네, 저는 그것이 안에 있는 것을 압니다, 좋습니다, 
우리가 하려고 하는 것은 그것을 보기 위해 예로써 그것을 사용하는 것 입니다.
그래서 저는 반복 멱법을 하는 것을 
만들 것 입니다. 
알겠죠? 
그리고 사실, 여러분이 여기 코드를 보면, 그리고 그것은 여러분의 인쇄물에도 있습니다, 
바로 첫 번째 것은, 바로 저기에 있는, x 1 입니다 – 
만약 제가 여러분에게 그것을 보라고 요청할 수 있으면요 – 그것은 그것을 하는 코드 입니다. 
그리고 저는 우리가 그것을 어떻게 분석할 것 인가 보다 코드에 덜 흥미가 있습니다, 
그러나 그것을 잠깐 살펴 봅시다.
좋아요, 여러분은 이 작은 코드를 볼 수 있습니다,
그것은 저기에서 루프를 가집니다, 그리고 그것은 무엇을 하나요? 
그것은 기본적으로 루프를 통해 순환 합니다, 
각 시간 마다 곱하면서요. 
그래서 루프의 첫 번째 시간에서, 답은 1 입니다. 
두 번째 시간에서, -- 미안해요, 그것이 루프로 들어가면,  
그것이 들어간 시간에서 – 나오면, 답은 a 입니다.
루프를 통한 다음 시간에 그것은 2제곱으로 갑니다. 
또 다음 루프를 통해 그것은 a^3 로 갑니다. 

Korean: 
그리고 그것은 지수를 세는 동안 
곱셈을 함께 모으는 것 입니다. 
그리고 여러분은 우리가 여기 마지막 테스트로 들어 갈 때 
그것을 볼 수 있습니다, 우리는 거기서 꺼내고 
우리는 답을 리턴 할 것 입니다.
실행시켜보면, 그것은 잘 실행될 것입니다. 
그런데 제가 생각하고 싶은 것은, 이것이 얼마나 많은 시간이 드는가? 입니다.
이 함수가 도는데 
얼마나 많은 단계가 드는가? 
자, 여러분은 그것을 볼 수 있습니다, 그렇죠? 
그것의 핵심 부분은 그 WHILE 루프 입니다.
그리고 제가 세려고 하는 단계들은 무엇 입니까?
그것들은 그 루프 내부에 있습니다 – 저는 잘못 된 안경을 쓰고 있습니다 
그래서 저는 눈을 가늘게 뜨고 보아야 합니다 
그리고 우리는 하나의 테스트를 하는데, 그것은 비교 입니다, 우리는 또 다른 테스트를 하는데 그것은 
곱셈 입니다 – 미안해요, 테스트가 아닙니다, 우리는 곱셈인 또 다른 단계를 가집니다 
또 다른 단계가 있는데 그것은 
뺄셈 입니다. 
그래서 루프를 통한 각 시간에서, 저는 세 단계를 할 것 입니다. 
세 가지 기본적인 연산을 합니다.
제가 루프를 얼마나 많이 돌려야 하나요? 
누군가 저를 도와주실분? 
손을 들어 얘기해줄래요? 
미안 합니다. b 번이죠.
여러분이 맞았습니다.
제가 각 시간을 계속 세기 때문에 – 대부분 저는 이 사탕을 내리지 않습니다, 
그것은 저를 힘들게 하거든요, 그래서 – 

English: 
And it's just gathering together
the multiplications
while counting down
the exponent.
And you can see it when we get
down to the end test here,
we're going to pop out of
there and we're going to
return the answer.
I could run it, it'll
do the right thing.
What I want to think about
though, is, how much
time does this take?
How many steps does it take
for this function to run?
Well, you can kind of
look at it, right?
The key part of that
is that WHILE loop.
And what are the steps
I want to count?
They're inside that loop--
I've got the wrong glasses so
I'm going to have to squint--
and we've got one test which
is a comparison, we've got
another test which is a
multiplication-- sorry, not a
test, we've got another step
which is a multiplication--
and another step that
is a subtraction.
So each time through the loop,
I'm doing three steps.
Three basic operations.
How many times do I go
through the loop?
Somebody help me out.
Hand up?
Sorry. b times.
You're right.
Because I keep counting down
each time around-- mostly I've
got to unload this candy, which
is driving me nuts, so--

English: 
thank you. b times.
So I've got to go 3 b steps.
All right, I've got to go
through the loop b times, I've
got three steps each time, and
then when I pop out of the
loop, I've got two more steps.
All right, I've got the
initiation of answer and the
return of it.
So I take 2 plus 3 b steps
to go through this loop.
OK.
So if b is 300, it takes 902
steps. b is 3000, it takes
9002 steps. b is 30,000
you get the point, it
takes 90,002 steps.
OK.
So the point here is, first of
all, I can count these things,
but the second thing you can
see is, as the size of the
problems get larger, that
additive constant, that 2,
really doesn't matter.
All right?
The difference between 90,000
steps and 90,002 steps, who
cares about the 2, right?
So, and typically, we're not
going to worry about those
additive constants.

Korean: 
고마워요. b 번 입니다. 
그래서 저는 3 번의 b 단계를 거쳐야 합니다. 
네, 저는 루프 b 번 돌아야 합니다, 
저는 각 시간 마다 3 단계를 가집니다, 
그리고 나서 제가 루프를 나왔을 때 저는 2 단계를 더 가집니다. 
그리고 그것의 리턴 값을 가집니다.
그리고 그것의 리턴 값을 가집니다. 
그래서 저는 이 루프를 돌기 위해 2 더하기 3 * b 단계를 가집니다. 
네. 
그래서 b 가 만약 300 이면, 그것은 902 단계를 가집니다. 
b 가 만약 3000 이면, 그것은 9002 단계를 가집니다. b 가 만약 30000 이면, 그것은 90002 단계를 가집니다.
네.
네. 그래서 여기서 중요한 것은, 첫 번째로, 저는 이것들을 셀 수 있습니다, 
그러나 여러분이 볼 수 있는 두 번째 것은,
문제의 크기가 점점 더 커짐에 따라, 첨가된 정수, 그 2는, 
정말로 중요하지 않습니다. 
그렇죠? 
90000 단계와 90002 단계 사이의 차이를 보면, 
누가 2 에 대하여 신경 쓰겠습니까, 네? 
그래서, 그리고 전형적으로, 우리는 그 첨가된 정수에 대해 
걱정하지 않을 것 입니다.

English: 
The second one is, this
multiplicative constant here
is 3, in some sense also
isn't all that crucial.
Does it really matter to you
whether your code is going to
take 300 years or 900
years to run?
Problem is, how big
is that number?
So we're going to typically
also not worry about the
multiplicative constants.
This factor here.
What we really want to worry
about is, as the size of the
problem gets larger, how
does this thing grow?
How does the cost go up?
And so what we're going to
primarily talk about as a
consequence is the rate of
growth as the size of the
problem grows.
If it was, how much bigger does
this get as I make the
problem bigger?
And what that really says is,
that we're going to use this
using something we're
going to just

Korean: 
두 번째 것은, 이 곱셈의 정수는 
3 입니다, 또한 어떤 의미에서 중요한 모든 것이 아닙니다. 
여러분의 코드가 도는데 300 년이 걸릴지 
900 년이 걸릴 지가 여러분에게 정말 중요 합니까? 
문제는, 그 수가 얼마나 큽니까? 입니다. 
그래서 우리는 전형적으로 또한 곱셈의 정수에 대해 또한
걱정하지 않을 것 입니다. 
여기 이 요소를요.
우리가 정말로 걱정하고 싶은 것은, 
문제의 크기가 점점 커지면서, 이것이 어떻게 커집니까? 
비용은 어떻게 올라 갑니까? 
그리고 그래서 우리가 주요하게 
결과로써 이야기 하려고 하는 것은 문제의 크기가 커질 때
증가의 비율 입니다. 
만약 그렇다면, 제가 문제를 더 크게 만들 때 
이것은 얼마나 더 커지나요? 
그리고 그것이 정말로 말하는 것은, 

English: 
call asymptotic notation--
I love spelling this word--
meaning, as in the limit as
the size of the problem gets
bigger, how do I characterize
this growth?
All right?
You'll find out, if you go on
to some of the other classes
in course 6, there are a lot of
different ways that you can
measure this.
The most common one, and the
one we're going to use, is
what's often called
big Oh notation.
This isn't big Oh as in, oh my
God I'm shocked the markets
are collapsing, This is called
big Oh because we use the
Greek letter, capital letter,
omicron to represent it.
And the way we're going to do
this, or what this represents,
let me write this carefully for
you, big Oh notation is
basically going to be an upper
limit to the growth of a

Korean: 
우리가 점근 표기 라고 부르는 것을 사용하는 이것을 사용해야 한다는 것 입니다
저는 이 단어의 철자를 쓰는 것을 좋아 합니다 – 
그것이 의미하는 것은, 문제의 크기가 한계 만큼 점점 더 커짐에 따라, 
제가 어떻게 이 증가를 특징 짓나요? 
네?
여러분은 알아 낼 것 입니다, 
만약 여러분이 코스 6 의 다른 수업을 계속 수강 한다면, 
여러분이 이것을 측정할 수 있는 많은 다른 방법들이 있습니다. 
가장 일반적인 것은, 그리고 우리가 사용할 하나는, 
우리가 big O 표기 법이라고 부르는 것 입니다. 
이것은 마켓이 붕괴할 때 충격 받아서 제가 오 마이 갓 이라고 말할 때의 오 가 아닙니다. 
이것은 big O 라고 불립니다, 
왜냐하면 우리는 그리스 문자, 대문자를 사용하기 때문 입니다, 
그리고 우리가 이것을 하는 방법은, 또는 이것이 표현하는 것은
제가 여러분을 위해 자세히 써드리겠습니다, big O 표기법은
기본적으로 함수의 성장에 제한이 될 것입니다.

Korean: 
입력값이 커지게 되면 말이죠.
이제 우리는 많은 예들을 볼 것 입니다, 
그리고 저는 이것들이 단어라는 것을 압니다, 제가 여러분에게 예를 주겠습니다. 
저는 f x 는 O(n^2) 안에 있다 라고 쓸 것 입니다. 
그리고 그것을 무엇을 말합니까? 
그것은 그 함수 f x 가 위에 있어야 한다는 것을 말합니다, 
그것에는 상한 한계가 있습니다,
이것은 이차 n, n 제곱 보다 더 빠르지 않습니다.
네.
그래서 첫 번째로, 여러분은 말합니다, 잠시만요, x 그리고 n ? 
자, 우리가 보려고 하는 것들 중 하나는
x 가 이 특정한 문제의 입력 이라는 것 입니다, n 은 x 의 크기의 척도 입니다. 
그리고 우리는 우리가 그것에 어떻게 올라 가는지 이야기 할 것 입니다.
N 은 x 의 크기를 측정 합니다.
네.
네. 이 예에서 저는 b 를 사용 합니다. 
좋아요, b 가 – b 는 제가 여기를 따라 가면서 변화하는 것 입니다,
그러나 그것은 다음과 같은 수 있습니다, 
입력이 리스트 이면 리스트에 얼마나 많은 요소들이 있습니까, 
입력이 스트링 이면, 얼마나 많은 숫자들이 스트링에 있습니까, 

English: 
function as the input grow--
as the input gets large.
Now we're going to see a bunch
of examples, and I know those
are words, let me give
you an example.
I would write f of x is in
big Oh of n squared.
And what does it say?
It says that function, f of x,
is bounded above, there's an
upper limit on it, that this
grows no faster than quadratic
in n, n squared.
OK.
And first of all, you say,
wait a minute, x and n?
Well, one of the things we're
going to see is x is the input
to this particular problem, n is
a measure of the size of x.
And we're going to talk about
how we come up with that. n
measures the size of x.
OK.
In this example I'd use b.
All right, as b get-- b is the
thing that's changing as I go
along here, but it could be
things like, how many elements
are there in a list if the input
is a list, could be how
many digits are there in a
string if the input's a

Korean: 
그것은 우리가 계속 함이 따라 인티져의 크기가 될 것 입니다. 
그렇죠? 
그리고 우리가 그리고 나서 하길 원하는 것은, 우리는 기본적으로 만들 것 입니다, 
우리는 증가를 어떻게 특징 지을 수 있나요 – 여러분에게 신의 축복이 있기를 – 
이 네모의 관점에서 이 문제의 크기 입니다 – 
미안해요, 이 지수적인 증가의 관점 입니다.
이제, 수학의 남은 한 가지가 있습니다. 
저는 속일 수 있습니다. 
저는 제가 상한 (upper bound) 을 원한다고 이야기 했습니다. 
저는 정말로 큰 상한을 가질 수 있습니다, 
이것은 지수적으로 증가 합니다. 
그것이 많이 도움이 되는 건 아닙니다.
보통 제가 이야기 하고 싶은 것은 
이 함수가 증가 할 때 가장 작은 크기의 클래스는 무엇입니까?
그것 모두를 가지고, 그것이 말하는 것은, 
우리가 쓰는 이것은 order b 입니다. 
이 알고리즘은 선형 입니다. 
여러분은 알 수 있을 것 입니다. 
저는 결과가 2 더하기 3 * b 라고 말했습니다. 
제가 b 를 정말 크게 만들 때, 이것을 어떻게 증가 하나요? 
그것은 b 처럼 증가 합니다. 
3은 중요하지 않습니다, 그것은 단지 상수 입니다, 그것은 
선형적으로 증가 합니다. 
그것을 말하는 또 다른 방법은, 예를 들어, 

English: 
string, it could be the size of
the integer as we go along.
All right.?
And what we want to do then, is
we want to basically come
up with, how do we characterize
the growth--
God bless you-- of this problem
in terms of this
quadra-- sorry, terms of
this exponential growth
Now, one last piece of math.
I could cheat.
I said I just want
an upper bound.
I could get a really big upper
bound, this thing grows
exponentially.
That doesn't help me much.
Usually what I want to talk
about is what's the smallest
size class in which this
function grows?
With all of that, what that
says, is that this we would
write is order b.
That algorithm is linear.
You can see it.
I've said the product
was is 2 plus 3 b.
As I make b really large, how
does this thing grow?
It grows as b.
The 3 doesn't matter, it's
just a constant,
it's growing linearly.
Another way of saying it is,
if I, for example, increase
the size of the input by
10, the amount of time

English: 
increases by 10.
And that's a sign that
it's linear.
OK.
So there's one quick example.
Let's look at another example.
If you look at x 2, this one
right here in your handout.
OK.
This is another way of doing
exponentiation, but this one's
a recursive function.
All right?
So again, let's look at it.
What does it say to do?
Well, it's basically saying
a similar thing.
It says, if I am in the base
case, if b is equal to 1, the
answer is just a.
I could have used if b is equal
to 0, the answer is 1,
that would have also worked.
Otherwise, what do I say?
I say, ah, I'm in a nice
recursive way, a to the b is
the same as a times a
to the b minus 1.
And I've just reduced that
problem to a simpler version
of the same problem.
OK, and you can see that this
thing ought to unwrap, it's
going to keep extending out
those multiplications until
gets down to the base
case, going to
collapse them all together.
OK.
Now I want to know what's the
order of growth here?

Korean: 
제가 만약 입력의 크기를 10 으로 증가 시키면, 시간의 양은 10 까지 증가 합니다. 
그리고 그것은 그것이 선형 이라는 표시 입니다.
네,
그래서 한 가지 간단한 예가 있습니다. 
또 다른 예가 있습니다. 
만약 여러분이 x 2 를 보면, 이것은 여러분의 핸드 아웃에 바로 여기에 있습니다. 
네,
이것은 멱법을 하는 또 다른 방법 입니다, 
그러나 이것은 순환적인 함수 입니다. 
그렇죠?
그래서 다시, 그것을 살펴 봅시다. 
그것이 무엇을 하라고 말하나요? 
자, 그것은 기본적으로 비슷한 것을 말할 것 입니다. 
그것을 말합니다, 만약 제가 기본적인 경우에 있으면, 만약 b 가 
1 과 같으면, 답은 그냥 a 입니다. 
제가 b 가 0 과 같다고 했으면, 답은 1 입니다, 
그것은 또한 작동 할 것 입니다.
그렇지 않으면, 제가 무엇을 말합니까? 
저는 말합니다, 아, 저는 좋은 순환적인 방법에 있습니다, 
a^b 는 a*(a^(b-1))과 같습니다. 
그리고 저는 문제를 같은 문제의 
더 간단한 버전으로 줄였습니다. 
네, 그리고 여러분인 이것이 풀어 져야 한다는 것을 알 수 있습니다, 
그것은 기본적인 경우로 내려 올 때 까지 
이 곱셈을 계속 늘려갈 것 입니다, 
그것들을 모두 붕괴시킬 것 입니다.
네,
네. 이제 여기서 저는 크기의 증가가 무엇인지 알고 싶습니다. 

English: 
What's the complexity of this?
Well, gee.
It looks like it's pretty
straightforward, right?
I've got one test there, and
then I've just got one thing
to do here, which has got
a subtraction and a
multiplication.
Oh, but how do I know how
long it takes to do x 2?
All right, we were counting
basic steps.
We don't know how long
it takes to do x 2.
So I'm going to show you
a little trick for
figuring that out.
And in particular, I'm going to
cheat slightly, I'm going
to use a little bit of abusive
mathematics, but I'm going to
show you a trick to
figure it out.
In the case of a recursive
exponentiator, I'm going to do
the following trick.
I'm going to let t of b be the
number of steps it takes to
solve the problem of size b.
OK, and I can figure this out.
I've got one test, I've got
a subtraction, I've got a
multiplication, that's three
steps, plus whatever number of
steps it takes to solve a
problem of size b minus 1.

Korean: 
이것의 복잡도는 무엇 입니까? 
자, 네.
그것은 이것이 꽤 직선적인 것 처럼 보입니다, 그렇죠? 
저는 거기서 하나의 테스트를 했습니다, 
그리고 나서 저는 여기서 할 것이 있구요, 
그것은 뺄셈과 곱셈이 있는것이죠. 
오, 그러나 x 2 를 하는데 얼마나 오래 걸리는지 제가 어떻게 알죠? 
맞아요, 우리는 기본적인 단계들을 세고 있었습니다. 
우리는 x 2 를 하는데 얼마나 오래 걸리는지 모릅니다. 
그래서 저는 여러분에게 그것을 알아 내는 작은 속임수를 
보여 줄 것 입니다. 
그리고 특히, 저는 약간 속일 것 입니다, 
저는 약간의 모욕적인 수학을 사용할 것 입니다, 그러나 저는 여러분에게 
그것을 알아 내는 속임수를 보여 줄 것 입니다.
반복되는 exponentiator 일 때는 
나는 이런 전략을 쓸겁니다. 
문제를 풀기위한 사이즈가 b일 경우 그 문제를 푸는데 걸리는 스텝또한
b스텝이라는 것입니다. 
좋아요, 그리고 이것을 발견했어요. 
테스트 하나를 할겁니다. 하나를 빼고, 
하나를 곱했어요. 세가지 단계죠. 
사이즈 b –1 의 문제를 해결할 수 있는 어떤 숫자든지 더하세요. 

Korean: 
좋습니다. 이게 바로 복귀관계 라고 불리는 것입니다. 
사실 이것을 해결하기 위한 더 좋은 방법들이 있어요. 
눈을 동그랗게 뜨고 볼 수 있는 것입니다. 
특별히, 어떻게 b-1 의 t 표현을
쓸 수 있을까요? 
같은 방법입니다. 
이것은 3+3+T(b-2)입니다. 
그렇죠?
저는 이것을 감소시키기 위해 정확히 같은 표현을 쓰고 있습니다. 
그리고 여러분이 알다시피 어떤 일이 일어날지 예상하고 있을 겁니다. 
제가 그것을 하나 감소시키면, 3+T(b-3)이 되겠죠. 이것은 3k+T(b-k)이라고 표현할 수 있습니다. 
그렇죠. 이와 같이 일반화 시킬 수 있겠네요.
네,
이제 막 확대했습니다.
언제 다 할 수 있을까요? 
이것을 어떻게 멈춰야 하죠? 
의견 있나요? 
교수들이 질문 하는 것이 싫지는 않나요? 
좋아요, 
사실, 나는 b-k 가 1이 되면 좋겠다고 생각합니다. 
맞죠? 
이것이 T(1) 로 감소하면, 가장 최저의 단계인 거죠. 

English: 
All right, this is what's called
a recurrence relation,
there are actually cool
ways to solve them.
We can kind of eyeball it.
In particular, how would I
write an expression for
t of b minus 1?
Well the same way.
This is 3 plus 3 plus
t of b minus 2.
Right?
I'm using exactly the same
form to reduce this.
You know, you can see what's
going to happen.
If I reduce that, it would be
3 plus t of b minus 3, so in
general, this is 3 k plus
t of b minus k.
OK.
I'm just expanding it out.
When am I done?
How do I stop this?
Any suggestions?
Don't you hate it when
professors ask questions?
Yeah.
Actually, I think I want
b minus k equal to 1.
Right?
When this gets down to t of
1, I'm in the base case.

Korean: 
그러니까 b- k 가 1이 되거나 
b – 1이 k 가 되면 끝나는 겁니다. 
좋아요, 기본단계로 내려가 봅시다. 
사이즈1로 문제를 해결할거예요, 
그리고 이 경우에는, 2가지 연산을 더 해야 되죠. 
그래서 이것들을 풀어보면, T(b)를 구할 때, k를 b-1로 놓으면,
 3(b-1) + T(1)라고 구할 수 있습니다. 그래서 T(1)은 2이니까 결국 T(b)는 3(b-1)+2 
또는 3b-1이라고 표현 할 수 있겠네요.
네,
다시, 이 문제 전체를 기본적으로 말해보면, 
명령b 는 선형입니다. 
하지만 이것 또한 좋습니다. 이것은 반복되는 것들이 간단하게 풀리지만 
시간의 분량적인 면의 복잡성은 결국 
같게 된다는 것을 보여줄 겁니다. 
여러분에게 사탕 하나를 빚졌군요.
고마워요
좋습니다.
이 시점에서, 만약 우리가 멈추게 된다면, 
여러분들은 모든 알고리즘이 선형이라고 생각 할겁니다. 
이것은 정말 지루하죠. 
하지만 그렇지 않아요, 
알겠죠?

English: 
So I'm done when b minus
k equals 1, or k
equals b minus 1.
Right, that gets me down to the
base case, I'm solving a
problem with size 1, and in that
case, I've got two more
operations to do, so I plug this
all back in, I-- t of b
is I'm going to put k for b
minus 1 I get 3 b minus 1 plus
t of 1, so t of 1 is 2, so this
is 3 b minus 1 plus 2, or
3 b minus 1.
OK.
A whole lot of work
to basically say,
again, order b is linear.
But that's also nice, it lets
you see how the recursive
thing is simply unwrapping but
the complexity in terms of the
amount of time it takes is
going to be the same.
I owe you a candy.
Thank you.
OK.
At this point, if we stop,
you'll think all algorithms
are linear.
This is really boring.
But they're not.
OK?

English: 
So let me show you another way
I could do exponentiation.
Taking an advantage
of a trick.
I want to solve a to the b.
Here's another way
I could do that.
OK.
If b is even, then a to the b
is the same as a squared all
to the b over 2.
All right, just move
the 2's around.
It's the same thing.
You're saying, OK, so what?
Well gee, notice.
This is a primitive operation.
That's a primitive operation.
But in one step, I've reduced
this problem in half.
I didn't just make
it one smaller, I
made it a half smaller.
That's a nice deal.
OK.
But I'm not always going
to have b as even.
If b is odd, what do I do?
Well, go back to what
I did before.
Multiply a by a to
the b minus 1.

Korean: 
여러분에게 내가 어떻게 누승법 (멱법)을 할 수 있는지 또 다른 방법을 보여 줄 겁니다. 
전략의 이점을 찾아보세요. 
a의 b승을 해결해 보려고 합니다. 
여기 우리가 할 수 있는 또 다른 방법이 있어요. 
자,
만약 b가 짝수라면, 
a^b가 (a^2)^(2/b)와 같습니다.(ex. 2^4 = (2^2)^(4/2)) 
좋아요, 두번째 라운드로 가봅시다. 
이것도 마찬가지죠. 
여러분이 말하는 것처럼, 좋아요, 
그래서 어떻게 되죠? 
이것은 원초적인 연산입니다. 
정말 원초적인 연산이죠. 
하지만 한 단계에서, 이 문제를 절반으로 줄여봤어요. 
하나를 더 작게 줄였을 뿐 아니라, 
절반보다 더 작게 했어요.
아주 괜찮은 방법이죠.
좋아요, 
하지만, b 가 항상 짝수라는 법은 없어요,
만약 b가 홀수면? 어떻게 해야 되죠? 
자, 전단계로 돌아가 봅시다. 
A의 B-1승에 a 를 곱해봅시다.

English: 
You know, that's nice, right?
Because if b was odd, then b
minus one is even, which means
on the next step, I can cut
the problem in half again.
OK?
All right. x 3, as you can see
right here, does exactly that.
OK?
You can take a quick look at
it, even with the wrong
glasses on, it says if a--
sorry, b is equal to 1, I'm
just going to return a.
Otherwise there's that funky
little test. I'll do the
remainder multiplied by 2,
because these are integers,
that gives me back an integer,
I just check to see if it's
equal to b, that tells me
whether it's even or odd.
And in the even case, I'd
square, divide by half, call
this again: in the odd case,
I go b minus 1 and
then multiply by a.
I'll let you chase it through,
it does work.
What I want to look
at is, what's the
order of growth here?
This is a little different,
right?
It's going to take a little bit
more work, so let's see if
we can do it.

Korean: 
괜찮은 방법이죠, 그렇죠?
만약 b 가 홀수라면, 그러면 b – 1은 짝수겠죠, 그것은 즉, 
다음단계에서 또다시 문제를 절반으로 줄일 수 있다는 것이죠. 
알겠습니까?
좋아요, 여러분이 바로 여기에서 볼 수 있는 x3는 정확해요 . 
그렇죠? 
재빠르게 한 번 보세요. 심지어 잘못된 안경을 썼을지라도, 
이것은 a가 – 미안해요, b가 1이군요.
A를 리턴하려고 합니다.
아니면 고풍스러운 작은 테스트 하나가 있어요. 
2로나눈 나머지를 구해보죠. 왜냐하면 
이것들은 정수들이고 그것은 저에게 하나의 정수를 줄 것이기 때문입니다.
저는 그냥 다시 체크해 보겠죠. 그것이 b와 같은지를요, 
그리고 그것이 그것이 짝수인지 홀수인지를 알려줄 것입니다. 
짝수인 경우, 제곱을하고 반으로 나누고 다시 이것을 호출 합니다.
홀수인 경우에는 b-1단계로 가서
a를 곱하겠죠.
그것을 한번 추적해보자면, 잘 되고 있네요. 
제가 여기서 보고 싶은 것은  
이곳의 성장순서가 무엇이냐 입니다.
이것은 조금 다르네요, 그렇죠?
좀 더 일을 하게 만들 텐데, 
우리가 그것을 할 수 있을지 한번 봅시다. 

Korean: 
B가 짝수일 경우에 다시 한번 T(b)가 제가 통과하려고 하는
단계의 숫자가 되게 끔 하겠습니다.
그리고  우린 이것을 눈을 크게 뜨고 볼 수 있을 겁니다. 맞죠? 
만약, b가 짝수라면 b가 1과 같은지 보는 테스트를 할 것이고 
그리고 나서 그 곱셈의 나머지를 구하기 위한 
테스트를 할 겁니다. 4까지요. 
그리고, 짝수의 경우에는 
제곱을 하고 나눌 것입니다. 
자 이제 저는 6개의 단계와 b/2 사이즈의 문제를 풀게 하는 어떤 것까지 
추가적으로 같이 갖게 됩니다.맞나요?
왜냐하면 그것은 재귀적 호출입니다. 
홀수로의 b 또한, 같은 종류의 것으로 할 수 있습니다. 
처음 4단계는 같고, 그것이 1인지 확인해 볼 것이고, 
짝수인지 확인도 할 것입니다. 그리고 나서 홀수의 경우라면, 
b에서 1을 빼는 5번째 단계를 해 볼 것이고, 
빠져나가 재귀적 문제를 해결할 것입니다. 그리고 나서 
한가지의 제곱을 더 할 것인데, 그것이 추가적인 6번째 단계가 될 것입니다. 
그 경우에는 T(b-1) 입니다.  
왜냐하면, 지금 더 작은 문제를 풀고 있는 중이기 때문이죠.

English: 
In the b even case, again I'm
going to let t of b be the
number of steps I want
to go through.
And we can kind of eyeball
this thing, right?
If b is even, I've got a test to
see if b is equal to 1, and
then I've got to do the
remainder, the multiplication,
and the test, I'm up to four.
And then in the even case, I've
got to do a square and
the divide.
So I've got six steps, plus
whatever it takes to solve the
problem size b over 2, right?
Because that's the recursive
call. b as odd, well I can go
through the same
kind of thing.
I've got the same first four
steps, I've got a check to see
is it 1, I got a check to see if
it's even, and then in the
odd case, I've got to subtract 1
from b, that's a fifth step,
I've got to go off and solve
the recursive problem, and
then I'm going to do one more
multiplication, so it's 6
plus, in this case,
t of b minus 1.
Because it's now solving
a one-smaller problem.

Korean: 
다음 단계에서 이것은 우리가 그것의 대체물로 얻는 것입니다. 
좋아요, 다음 단계에서 저는 다시 짝수의 경우로 돌아오겠습니다. 
이것은 6가지의 단계를 더 가게 될 것 입니다. 그리고 거기에 T(b-1)단계를 추가합니다. 
죄송합니다. 2를 넘는 것에 대해서요. 
왜냐하면 b 마이너스 1은 지금 짝수이기 때문이죠. 
여기서는 자세한 것을 잘 몰라도 됩니다. 
저는 단지 여러분이 그것이 그렇게 되는 이유를 알기 원할 뿐입니다. 
지금 제가 가지고 있는 것은 아주 좋은 것입니다. 
일반적으로 다른 경우에서 T(b)--
(그리고 이곳은 제가 아주 조금 표기법을 남용하려는 곳입니다.) 하지만 저는 
기본적으로 t에 의해서 그것의 경계를 지을 수 있습니다.T(b)가 2를 넘는 추가적인 경우와 12단계가 있습니다. 
그리고 그 남용은 여러분도 알다시피 꽤 맞지 않습니다. 그것이 모두
준비가 됐는지 안됐는지에 따라 다릅니다. 하지만 여러분이 다른 경우에서 볼 수 있듯이 
12단계가  지난 후, 2는 이것을 지나 실행될 것입니다. 
2/ b의 사이즈의 문제에 이르기까지 말이죠
그것이 왜 좋은 것입니까?
음, 다른 12단계를 지나 우리는 
T(b/4)의 문제에 이르게 될 것입니다. 
그리고 만약 그것의 한 레벨을 더 끌어올린다면 , 

English: 
On the next step though, this,
we get substituted by that.
Right, on the next step, I'm
back in the even case, it's
going to take six more steps,
plus t of b minus 1.
Oops, sorry about
that, over 2.
Because b minus 1 is now even.
Don't sweat the details here,
I just want you to see the
reason it goes through it.
What I now have, though,
is a nice thing.
It says, in either case, in
general, t of b-- and this is
where I'm going to abuse
notation a little bit-- but I
can basically bound it by t, 12
steps plus t of b over 2.
And the abuse is, you know,
it's not quite right, it
depends upon whether it's all
ready, but you can see in
either case, after 12 steps, 2
runs through this and down to
a problem size b over 2.
Why's that nice?
Well, that then says after
another 12 steps, we're down
to a problem with size
t of b over 4.
And if I pull it out one more
level, it's 12 plus 12 plus t

Korean: 
그것은 12+12+T(b/8)이 되겠죠. 
이것은 일반적으로 말하면 k단계 후에는, 
12k+ (b/2^k)가 되겠죠.
도대체 언제 끝나나요? 
도대체 언제 근본적 문제에 이르게 될까요? 
누가 저 좀 도와주세요  
전 지금 무엇을 보고 있나요? 
네, 
여러분은 제 앞에서 약간 뛰고 있군요. 하지만 
기본적으로 이것이 1과 같을 때 제가 다 끝내는 것입니다. 맞죠? 
왜냐하면 제가 근본적 문제에 이를 때,  k가 1과 같을 때까지 
b가 2를 넘을 때 끝나는 것입니다. 그리고 여러분이 명백히 맞습니다. 
K가 log₂b일 때가 그 것입니다.
여러분은 아주 먼 길을 왔네요. 
제가 이것을 멀게 만들었는지 아닌지 잘 모르겠네요. 
감사합니다.
네. 
거기에 몇 개의 정수가 있습니다. 하지만 이것은 로그 의 순서입니다. 
대수학적으로요. 

English: 
of b over 8, which in general is
going to be, after k steps,
12 k because I'll have 12 of
those to add up, plus t of b
over 2 to the k.
When am I done?
When do I get down
to the base case?
Somebody help me out.
What am I looking for?
Yeah.
You're jumping slightly ahead of
me, but basically, I'm done
when this is equal
to 1, right?
Because I get down to the base
case, so I'm done when b u is
over 2 to the k is equal to 1,
and you're absolutely right,
that's when k is log
base 2 of b.
You're sitting a long ways back,
I have no idea if I'll
make it this far or not.
Thank you.
OK.
There's some constants
in there, but this
is order log b.
Logarithmic.

Korean: 
이것은 문제입니다. 
아주 큰 문제죠. 
그리고 저는 두 번째로 어떤 예를 보여줄 것입니다. 
특징을 보기 보다는 단지 알아 들으세요 . 
처음 두 가지의 경우, 문제가 각 단계에서
1씩 감소합니다. 
반복되든 말든, 
그것이 선형이라는 뜻 입니다.
이 경우, 문제의 크기를 절반으로 줄였어요. 
이것이 로그라는 좋은 신호죠, 그리고 왜 로그가 좋은 것인지 
알아보기 위해 두 번째를 다시 볼 거예요. 
그렇지만, 여러분에게 한가지 수업을 더 보여주려고 합니다. 미안합니다, 
알고리즘에 대한 두 가지 강의를 더 보여  줄 겁니다. 
다음 것을 봅시다 g—그리고 여러분의 인쇄물을 보면, 
버그가 하나 있어요, 그것은 g(n)이나 g(m)일겁니다. 미안해요, 
어느 정도 고쳤어야 했는데 캐치하지 못했네요.
자
자, 여기서 증가된 순서는, 
누구 맞혀볼 사람 있나요? 
조교들 중에, 누구 아는 사람? 
좋아요,
한 번 봅시다. 
두 개의 루프가 있어요. 
그렇죠? 

English: 
This matters.
This matters a lot.
And I'm going to show you an
example in a second, just to
drive this home, but notice
the characteristics.
In the first two cases,
the problem reduced
by 1 at each step.
Whether it was recursive
or iterative.
That's a sign that it's
probably linear.
This case, I reduced the size
of the problem in half.
It's a good sign that this is
logarithmic, and I'm going to
come back in a second to why
logs are a great thing.
Let me show you one more class,
though, about-- sorry,
let me show you two more classes
of algorithms. Let's
look at the next one g-- and
there's a bug in your handout,
it should be g of n and m, I
apologize for that, I changed
it partway through and
didn't catch it.
OK.
Order of growth here.
Anybody want to volunteer
a guess?
Other than the TAs, who know?
OK.
Let's think it through.
I've got two loops.
All right?

Korean: 
여러분도 알다시피 우리는 이미 다른 루프 하나를 보았어요,
그 루프는 안에 뭐가 있느냐에 따라 선형으로 보이기도 했었어요, 그렇지만 
이것의 경우를 봅시다. 
G가 있는 루프가 두 개가 있어요. 
G가 무엇을 하죠? 
X 초기값이 있고 i는 범위안에 있어요. 
그러니까 기본적으로는 N-1 까지 있습니다. 
이제 무엇을 해야 할까요? 
네, 이 안에, 또 다른 루프가 있고, 
m-1까지 범위 안에 j가 있어요. 
내부 루프의 복잡성이 어떻게 되죠? 
뭐라고요?
네, 
나에게 전체적인 부분을 말하고 있군요,
단지 여기 내부 루프의 복잡성이 무엇일까요?
이 조각에서만요. 
이 루프를 몇 번이나 돌렸죠? M.
맞나요? 
여러분이 올바른 방향으로 가고 있으니까
곧바로 두 번째 답으로 넘어가 보겠습니다. 
내부 루프는, 여기에 이 부분을, 저는 m번 했어요.
내부에서 한 단계가 있네요. 
그렇죠?
이 루프는 몇 번 돌렸죠? 
아, n번 했군요, i의 각각의 값을 보니까요.
M을 할거예요. 그러면, 여러분이 말한 답에 근접합니다, 그렇죠? 

English: 
We already saw with one of the
loops, you know, it looked
like it might be linear,
depending on what's inside of
it, but let's think
about this.
I got two loops with g.
What's g do?
I've got an initialization of
x, and then I say, for i in
the range, so that's basically
from 0 up to n minus
1, what do I do?
Well, inside of there, I've got
another loop, for j in the
range from 0 up to m minus 1.
What's the complexity
of that inner loop?
Sorry?
OK.
You're doing the whole
thing for me.
What's the complexity just
of this inner loop here?
Just this piece.
How many times do I go
through that loop? m.
Right?
I'm going to get back to your
answer in a second, because
you're heading in the
right direction.
The inner loop, this part
here, I do m times.
There's one step inside of it.
Right?
How many times do I go
through that loop?
Ah, n times, because for each
value of i, I'm going to do
that m thing, so that is, close
to what you said, right?
The order complexity here, if
I actually write it, would

Korean: 
여기서 복잡성의 순서는, 내가 쓴다면, 이렇게 될 겁니다- 
미안합니다 , n곱하기 m 을 명령하세요, 그러면 만약 m이 n 과 같다면,
n제곱이 되겠죠. 이차가 됩니다. 
이건 좀 다른 방식 이예요.
좋습니다.
내가 무엇을 하고 있죠? 
알고리즘의 예시를 만들고 있어요.
다시, 여러분이 코드의 특성을 그리는 방법을 
보기 시작했으면 좋겠어요. – 알고리즘의 특성 말입니다. 
코드라고 부르지 맙시다- 복잡성이라고 하죠. 
금방 여기로 돌아 올 거예요, 
그런데 하나의 예시를 더 봤으면 좋겠네요. 그리고 사용할 수 있는 첨단 기술의
아주 비싼 프롭이 있어요. 
좋아요. 
우리가 어디까지 했든지 4번째나 5번째가 되겠군요,
다섯 번째 같네요.
하노이의 타워라고 불리는 문제의 예시가 있어요. 
이 문제에 대해서 들어본 사람 있나요? 
몇 가지 시안이 있어요.
좋아요. 
내가 말했던 그 이야기가 여기 있네요. 
하노이의 중간에 절이 하나 있어요.
그 절에는, 매우 큰 다이아몬드로 뒤덮인 우편물들이 있어요, 

English: 
be-- sorry, order n times m, and
if m was equal to n, that
would be order n squared,
and this is quadratic.
And that's a different
behavior.
OK.
What am I doing?
Building up examples of
algorithms. Again, I want you
to start seeing how to map the
characteristics of the code--
the characteristics of the
algorithm, let's not call it
the code-- to the complexity.
I'm going to come back to that
in a second with that, but I
need to do one more example,
and I've got to use my
high-tech really expensive
props.
Right.
So here's the fourth or fifth,
whatever we're up to, I guess
fifth example.
This is an example of a problem
called Towers of Hanoi.
Anybody heard about
this problem?
A few tentative hands.
OK.
Here's the story as
I am told it.
There's a temple in the
middle of Hanoi.
In that temple, there
are three very large

English: 
diamond-encrusted posts, and on
those posts are sixty-four
disks, all of a different
size.
And they're, you know, covered
with jewels and all sorts of
other really neat stuff.
There are a set of priests in
that temple, and their task is
to move the entire stack of
sixty-four disks from one post
to a second post. When they do
this, you know, the universe
ends or they solve the financial
crisis in Washington
or something like that actually
good happens, right?
Boy, none of you have 401k's,
you're not even wincing at
that thing.
All right.
The rules, though, are, they
can only move one disk at a
time, and they can never cover
up a smaller disk with a
larger disk.
OK.
Otherwise you'd just move the
whole darn stack, OK?
So we want to solve
that problem.
We want to write a piece of
code that helps these guys
out, so I'm going to show
you an example.
Let's see if we can figure
out how to do this.
So, we'll start with
the easy one.
Moving a disk of size 1.
OK, that's not so bad.
Moving a stack of size 2, if I
want to go there, I need to
put this one temporarily over
here so I can move the bottom

Korean: 
그리고 그 우편물들 위에는 서로 다른 크기의  
64개의 디스크가 있어요,
그리고 그것들은, 아주 깔끔한 물건 같은 것들과 
보석으로 쌓여있죠. 
그 절에는 성직자들이 있고 
그들의 임무는 그 64개의 무더기를 첫 번째 우편에서 
두 번째 것으로 옮기는 것입니다.
그들이 이것을 할 때에는, 
우주의 종말이나 그들이 워싱턴의 경제적인 위기를 해결한다거나 
그런 좋은 일들이 일어날 때죠. 아시겠어요?
여러분 중 아무도 401k 가 없네요, 
여러분들은 그런 것에 놀라지도 않는군요.
좋아요, 
그렇긴 하지만, 규칙들은, 한 번에 하나의 디스크만 옮길 수 있어요,
그리고 그들은 큰 디스크로 작은 디스크를
절대 덮을 수 없죠. 
좋아요.
아니면 여러분들은 전체를 옮기는 게 나아요, 알겠어요?
그러면 우리는 그 문제를 해결하길 원합니다. 
이것들을 빼낼 수 있게 도와주는 코드 한 조각을 써봅시다,
예시를 하나 보여줄게요, 
이 문제를 해결하고 나서 이것을 하는 방법을 봅시다.
그러면, 쉬운 것부터 시작할게요. 
사이즈1인 디스크를 옮기세요, 
좋습니다, 나쁘지 않아요.
사이즈2 한 더미를 옮기세요, 만약 거기로 가려고 한다면, 
이것을 일시적으로 여기에 두면 옮기기 전에

Korean: 
밑에 것을 옮길 수 있어요.
다시, 사이즈3 한 무더기를 옮기세요, 만약 저기로 옮기길 원한다면,
밑에 것을 옮기기 전에 남은 것들을 여기에 
확실히 옮겨야 합니다. 더 큰 것으로 더 작은 것을
어떤 것도 덮을 수는 없지만 그것을 얻을 수는 있죠.
사이즈4 무더기는, 다시 해보면, 이것을 처음으로 할거예요, 
아, 아닙니다. 다시 해볼게요. 
거기를 처음으로 갈 겁니다, 그러면 여기로 이것을 옮길 수 있죠, 
그러면 저기가 베이스파트가 될 거예요, 
여기에 이것을 두기 전에 하나를 저쪽에 놓으면 좋겠어요, 
아래 것을 어디에 옮겨야 하는지 결과적으로 알아냈습니다, 
이제 그것들이 게시될 곳에 다다르기 전에
잘못된 방법으로 아래 것을 덮지 않게 
정말 주의 해야 합니다. 
됐나요? 
(박수) 
내가 말하는 것은, 나는 이 방법으로 하버드 스퀘어에서
돈을 벌 수 있죠, 그렇겠죠?
좋아요, 다섯 번 째 할 준비 됐나요? 
해결책 있나요? 
보기 쉽지 않죠. 
좋습니다, 그런데 이것은 사실 교육적인 순간에는 
아주 괜찮은 것 중 하나죠. 
반복적으로 생각하기 아주 좋은 예시입니다. 
이 문제를 반복적으로 생각하기 원했다면- 
반복적인 생각으로 내가 원하는 것이 무엇이죠?
동시에 더 작은 크기의 문제로

English: 
one before I move it over.
Moving a stack of size 3, again,
if I want to go over
there, I need to make sure I
can put the spare one over
here before I move the bottom
one, I can't cover up any of
the smaller ones with
the larger one, but
I can get it there.
Stack of size 4, again I'm going
there, so I'm going to
do this initially, no I'm not,
I'm going to start again.
I'm going to go there initially,
so I can move this
over here, so I can get the base
part of that over there,
I want to put that one there
before I put this over here,
finally I get to the point where
I can move the bottom
one over, now I've got to be
really careful to make sure
that I don't cover up the bottom
one in the wrong way
before I get to the stage where
I wish they were posts
and there you go.
All right?
[APPLAUSE]
I mean, I can make money at
Harvard Square doing this
stuff, right?
All right, you ready
to do five?
Got the solution?
Not so easy to see.
All right, but this is actually
a great one of those
educational moments.
This is a great example
to think recursively.
If I wanted to think about this
problem recursively--
what do I mean by thinking
recursively?
How do I reduce this to a
smaller-size problem in the

Korean: 
어떻게 감소시킬 수 있을까요? 
또한, 만약 내가 이렇게 한다면, 이것은 정말 쉬워질 겁니다. 
만약 이 무더기를 이 곳으로 옮기려고 한다면, 사이즈n-1 한 무더기를 가져갈 겁니다,
여분의 스팟으로 그것을 옮기세요, 이제
기본 디스크를 옮길 수 있습니다, 그리고 나서 
사이즈n-1인 무더기를 옮겨야겠어요. 
쓰여진 대로 했습니다, 알겠어요?
그리고 여기에 코드가 있네요. 
타워라고 불렸죠. 
단지 여러분이- 여기를 보세요.
이 것들의 사이즈가 무엇인지 논쟁이 좀 필요한데, 
그리고 나서 세 개의 포스트에 라벨을 붙이세요. 
A부터 ,a까지, 그리고 하나 남네요. 
사실, 이것을 보면—다른 쪽에 잠깐 가볼게요- 
좋아요, 타워 하나를 옮겼습니다, 
사이즈2부터 여분의 것까지 그리고 이것들이 내가 한 것들입니다. 
그리고 만약 내가 타워들을 옮기려고 한다면, 

English: 
same instant?
And so, if I do that, this
now becomes really easy.
If I want to move this stack
here, I'm going to take a
stack of size n minus 1, move
it to the spare spot, now I
can move the base disk over,
and then I'm going to move
that stack of size n
minus 1 to there.
That's literally
what I did, OK?
So there's the code.
Called towers.
I'm just going to have you--
let you take a look at it.
I'm giving it an argument,
which is the size of the
stack, and then just labels
for the three posts.
A from, a to, and a spare.
And in fact, if we look at
this-- let me just pop it over
to the other side--
OK, I can move a tower, I'll say
of size 2, from, to, and
spare, and that was
what I did.
And if I want to move towers,
let's say, size 5, from, to,

Korean: 
사이즈5라고 할게요, 남는 것 까지요. 어떻게 옮기는지에 대한 
설명이 있네요. 
64개를 다 하지 않아도 되겠군요.
좋습니다.
좋아요, 
매우 재미있군요, 박수도 약간 받았고, 
나는 이것이 항상 좋지만 어떻게 
반복적으로 할 수 있는지 보여드리겠습니다.
여러분들은 묘사를 들은 적이 있죠,
코드를 쓰기는 쉽습니다, 사실.
이것이 반복적인 버전입니다. 
하나를 반복적으로 생각하는 것이 훨씬 쉬워요.
내가 꼭 말하고 싶은 것은,
여기에서 증가의 명령이 무엇이죠? 
이 알고리즘의 복잡성이 무엇일까요? 
그리고 다시, 약간은 모욕적일 수 있는 표기를 할 겁니다,
그리고 약간 더 복잡할 거예요, 그렇지만 
우리는 자세히 볼 거예요. 
알겠죠?
여기의 코드가 있죠, 만약 내가 사이즈 n 의 타워를 옮기려고 한다면, 
내가 무엇을 해야 하죠? 
만약 기본적인 경우라면 알아보기 위해 테스트를  했을 거예요. 그것이 아니라면,
사이즈n-1의 타워로 이동해야 할 필요가 있어요, 
사이즈1의 타워로 이동해야 하고, 두 번째로 또 이동해야 합니다-

English: 
and spare, there are
the instructions
for how to move it.
We ain't going to
do sixty-four.
OK.
All right.
So it's fun, and I got a little
bit of applause out of
it, which is always nice for me,
but I also showed you how
to think about it recursively.
Once you hear that description,
it's easy to
write the code, in fact.
This is a place where the
recursive version of it is
much easier to think about
than the iterative one.
But what I really want to talk
about is, what's the order of
growth here?
What's the complexity
of this algorithm?
And again, I'm going to do it
with a little bit of abusive
notation, and it's a little more
complicated, but we can
kind of look at.
All right?
Given the code up there, if I
want to move a tower of size
n, what do I have to do?
I've got to test to see if I'm
in the base case, and if I'm
not, then I need to move a tower
of size n minus 1, I
need to move a tower of size
1, and I need to move a
second-- sorry about that--
a second tower of

Korean: 
아, 미안합니다- 사이즈n-1 인 두 번째 타워입니다. 
좋아요, T(1)도 또한 감소할 수 있어요.
사이즈1 타워의 경우, 기본적으로 
2가지 해야 될 것이 있어요, 맞나요? 
테스트를 해야겠네요, 그리고 나서 이동할 겁니다.
형식적인 공식입니다. 
이제, 
여러분이 살펴 보고 말할 수 있을 거예요,
 이것들은 우리가 위에서 본 것과 매우 비슷해요.
그렇죠? 
우리는 같은 문제 중에서 사이즈를 1까지 줄인 끊임없는 첨가물이 
약간 있는 더 간단한 버전이 있었어요.
하지만 두 가지 문제가 있네요. 
한 번 봅시다.
어떻게 T(n-1)를 표현할 대체할 수 있을까요?
다시 대체해 보세요 T(n-1)는
3+2 T(n-2)입니다. 
그러니깐 이것은 3 + 2*3 +4 T(n-2).
좋아요.  
다시 대체해 본다면, 

English: 
size n minus 1.
OK. t of 1 I can also reduce.
In the case of a tower of size
1, basically there are two
things to do, right?
I've got to do the test, and
then I just do the move.
So the general formula is that.
Now.
You might look at that and say,
well that's just a lot
like what we had over here.
Right?
We had some additive constant
plus a simpler version of the
same problem reduced
in size by 1.
But that two matters.
So let's look at it.
How do I rea-- replace the
expression FOR t of n minus 1?
Substitute it in again. t
of n minus 1 is 3 plus 2
t of n minus 2.
So this is 3, plus 2 times
3, plus 4 t minus 2.
OK.
And if I substitute it again, I
get 3 plus 2 times 3 plus 4

English: 
times 3 plus 8 t n minus 3.
This is going by a little
fast. I'm just
substituting in.
I'm going to skip some steps.
But basically if I do this, I
end up with 3 times 1 plus 2
plus 4 to 2 to the k
minus 1 for all of
those terms, plus 2--
I want to do this right, 2 to
the k, sorry-- t of n minus k.
OK.
Don't sweat the details, I'm
just expanding it out.
What I want you to see is,
because I've got two versions
of that problem.
The next time down I've
got four versions.
Next time down I've got
eight versions.
And in fact, if I substitute, I
can solve for this, I'm done
when this is equal to 1.
If you substitute it all
in, you get basically
order 2 to the n.
Exponential.
That's a problem.

Korean: 
3+2*3+4*3+8T(n-3) 을 얻겠네요. .
약간 빠르게 진행됩니다. 
대입해 보겠습니다
몇 단계는 넘어가겠습니다. 
하지만 이것을 한다면 기본적으로, 나는    
3*(1+2+4+…+2^k-1)+2를 해서 끝낼 것입니다
—정확히 이렇게 하면 좋겠어요 , 2의 k승을더하세요, 미안합니다--
T(n-k)네요.
좋아요.
세부적인 것에 사로잡혀 있지 마세요. 단지 확장할 겁니다.
여러분이 알았으면 하는 것은, 이 문제의
두 가지 버전이 있기 때문이죠.
다음시간에는 네 가지 버전을 써볼 겁니다.
그 다음시간에는 여덟 가지 버전이고요.
그리고 사실, 대입한다면, 이것을 해결할 수 있어요, 
1과 같게 될 때 완성한 것입니다.
만약 여러분이 전체를 대입한다면, 여러분은 기본적으로
2의n승을 얻게 됩니다
지수, 
그것이 문제입니다.

Korean: 
지금, 이것도 또한 근본적으로 이 알고리즘이
어떤 종류로 나뉘는지에 대한 것이죠, 이것은 
지수 총액을 가질 것입니다. 
하지만 n이 들어서면, 매우 급속도로 성장합니다, 
그리고 잠시 후에 예시를 하나 보여드릴게요
다시, 여러분이 알기를 원하는 것은,
이것의 특성에 주목하세요.
이 반복적인 콜은 2 가지의 작은 사이즈의 
작은 문제들이 있어요, 하나가 아니고요.
그리고 그것은 큰 차이점을 만들어 내죠. 
얼마나 큰 차이점을 그것이 만들어내는지 
여러분 에게 보여 드릴게요. 두 가지 숫자를 실행해 봅시다.
N이 1000이라고 가정해보고 10억 분의 1초의
속도로 돌려봅시다. 
우리는 로그, 선형, 이차, 그리고 지수를 쭉 보아 왔습니다. 
그러니까, 다시, 여기에서 반복되는  것이 두 개 정도 있을 겁니다, 하지만 
이것 같은 것을 줄게요. 
만약 제가 10억 분의 1초의 속도로 실행한다면, 

English: 
Now, it's also the case that
this is fundamentally what
class this algorithm falls
into, it is going to take
exponential amount of time.
But it grows pretty rapidly, as
n goes up, and I'm going to
show you an example
in a second.
Again, what I want you
to see is, notice the
characteristic of that.
That this recursive call had two
sub-problems of a smaller
size, not one.
And that makes a
big difference.
So just to show you how big a
difference it makes, let's run
a couple of numbers.
Let's suppose n is 1000,
and we're running
at nanosecond speed.
We have seen log, linear,
quadratic, and exponential.
So, again, there could be
constants in here, but just to
give you a sense of this.
If I'm running at nanosecond
speed, n, the size of the

English: 
problem, whatever it is, is
1000, and I've got a log
algorithm, it takes 10
nanoseconds to complete.
If you blink, you miss it.
If I'm running a linear
algorithm, it'll take one
microsecond to complete.
If I'm running a quadratic
algorithm, it'll take one
millisecond to complete.
And if I'm running
an exponential
algorithm, any guesses?
I hope Washington doesn't take
this long to fix my 401k plan.
All right?
10 to the 284 years.
As Emeril would say, pow!
That's a some spicy whatever.
All right.

Korean: 
문제의 사이즈는, 그것이 무엇이 됐든 1000입니다. 그리고 저는 
로그 알고리즘을 갖습니다. 그것은 완성하는데 100억 분의 1초가 걸립니다.
눈을 한 번 깜빡 하면 
놓치게 되죠.
만약 선형 알고리즘을 실행한다면,
그것은 완성하는데
100만 분의 1초가 걸려요. 
그리고 지수 알고리즘을 실행하면,
어떻게 될까요? 
워싱턴이 나의 401k 계획을 수정하는데 이렇게 오래 걸리지 않기를 희망합니다. 
이해가 되나요?
10의284승년이 걸립니다.
Emeril이 펑! 이라고 말하겠네요.
어쨌든 약간 흥미롭군요.
좋습니다. 

English: 
Bad jokes aside, what's
the point?
You see, these classes have
really different performance.
Now this is a little
misleading.
These are all really fast, so
just to give you another set
of examples, I'm not
going to do the--
If I had a problem where the log
one took ten milliseconds,
then the linear one would take
a second, the quadratic one
would take 16 minutes.
So you can see, even the
quadratic ones can
blow up in a hurry.
And this goes back to
the point I tried
to make last time.
Yes, the computers are really
fast. But the problems can
grow much faster than you can
get a performance boost out of
the computer.
And you really, wherever
possible, want to avoid that
exponential algorithm, because
that's really deadly.
Yes.
All right.
The question is, is there a
point where it'll quit.
Yeah, when the power goes out,
or-- so let me not answer it
quite so facetiously.
We'd be mostly talking
about time.

Korean: 
안 좋은 농담이 섞였네요. 요지가 무엇이죠? 
여러분이 알다시피, 이런 종류들은 정말 다른 작업입니다. 
약간 오해가 있었네요.
이것은 모두 정말 빠릅니다, 그래서 또 다른 예시 세트를 보여줄게요,
만약 로그1이 1000만 분의 1초가 걸리는
문제가 있다면, 선형 알고리즘은 
1초가 걸리고, 이차 알고리즘은
16분이 걸립니다. 
여러분이 보다시피, 이차 알고리즘 조차도
순식간에 사라질 것입니다.
네, 
컴퓨터는 정말 빠르죠. 
하지만 문제는 여러분이 컴퓨터로 실행하는 것 보다
훨씬 빠르게 자라납니다. 
그리고 여러분은 정말, 가능하면 어디든지, 
지수 알고리즘을 피하길 원하죠. 왜냐하면 정말 치명적이거든요. 
네.
좋아요, 
질문은, 그것이 끝나는 포인트입니다. 
네, 전원이 꺼지면, 또는- 
농담으로 대답하지 않겠습니다. 
우리는 대게 시간에 대해서 이야기 할 겁니다.

Korean: 
사실, 만약 내가 이것들 중 하나를 실행했다면, 
오도독오도독 날아갈 겁니다.
공간 문제 때문에 어떤 시점에서 끝나게 될 거예요,
만약 그렇지 않다면 추가적인 공간이 
사용되지 않는 알고리즘을 써야겠죠.
좋아요, 
이런 것들은 계속 쌓이게 되고 결국에는 
공간이 부족하게 될 겁니다. 
그리고 더 많은 문제가 생기겠죠, 하지만.
알고리즘은 계산하는데 이렇게 오래 걸릴 거라는것을
알지 못합니다, 오도독오도독 씹기 바쁘죠, 
만약 그런 문제가 생기면, 한 번 보세요.
좋아요,
좋은 질문입니다, 고마워요. 
좋습니다, 
여기에서 하나 더 확장된 예를 해봤으면 좋겠어요, 
우리가 해야 할 또 다른 조각이 있거든요, 하지만 나는 이것을 데이터 수집을 했으면 합니다, 
중요하거든요. 다시 시도해 보고 다음 방법으로
말해줄게요. 
저는 여러분이 알고리즘의 종류들을 알고 
알고리즘의 복잡성에 알고리즘의 성능을 
알아서 매치하길 바랍니다.
알겠습니까?
선형 알고리즘은 한번 지나갈 때, 
여러분이 불변의 양인1로, 문제를 줄여가는 
경향이 있습니다. 
만약  2로 그것을 줄이면 그것은 같은 것이 될 것입니다. 
문제의 크기가  n인 곳에서 n-1인 곳까지 
어디서 가야합니까?

English: 
In fact, if I ran one of these
things, it would just keep
crunching away.
It will probably quit at some
point because of space issues,
unless I'm writing an algorithm
that is using no
additional space.
Right.
Those things are going to stack
up, and eventually it's
going to run out of space.
And that's more likely to
happen, but, you know.
The algorithm doesn't know that
it's going to take this
long to compute, it's just busy
crunching away, trying to
see if it can make it happen.
OK.
Good question, thank you.
All right.
I want to do one more extended
example here., because we've
got another piece to do, but I
want to capture this, because
it's important, so let me
again try and say it the
following way.
I want you to recognize classes
of algorithms and
match what you see in the
performance of the algorithm
to the complexity of
that algorithm.
All right?
Linear algorithms tend to
be things where, at one
pass-through, you reduce
the problem by a
constant amount, by one.
If you reduce it by two, it's
going to be the same thing.
Where you go from problem of
size n to a problem of
size n minus 1.

Korean: 
전형적인 로그 알고리즘은 여러분이 어떤 승인자로
문제를 감소시키는 것입니다.
여러분은 그것들을 절반으로 감소시키죠.
3분의 1로도 감소시키구요.
이해가 되었나요?
2차 알고리즘은 이런 경향이 있습니다- 추가적인 것들을 알려드리려고 하는데요,
하지만, 2배 집합,3배  집합의 것들은 
2차 알고리즘이나 큐빅 알고리즘과 같습니다. 
좋아요. 여러분이 알다시피- 혼란스럽게 하지 마세요- 
더블 루프 2차 알고리즘은 여러분이 어떤 것의 하나의 세트를 하고 있고,
다른 몇 배의 것을 하고 있기 때문입니다
그리고 그것은 형식적인 신호죠.
거기서 여러분이 갖고 있는 어떤 것의 말입니다.
좋습니다. 
그리고 나서 지수입니다. 여러분이 보다시피 
제가 문제한가지를 형식적으로 줄여나가 더 작은 사이즈를 갖는 2개 혹은 
더 많은 부분 문제들로 만들 때입니다.
그리고 여러분은 이것은 복잡함을 가져오고 
실제 형식에서 보기에 더 흥미로운 것들을 상상할 수 있습니다. 하지만 
그것들은 여러분이 봐야 하는 것입니다.
이제,
이 마지막 예제를 우리가 해 보기 전에 다른 2가지 것이 있습니다. 
한가지는, 여러분을 상기 시켜 보자면, 우리가 흥미로워 하는 것은 
점근선의 성장입니다. 
제가 이 문제의 사이즈를 크게 만드는 것처럼 그것은 어떻게 하는 걸까요?
그리고 저는 또한 여러분들에게 상기시킬 것입니다.
그리고 우리는 이것을 다음 예제에서 

English: 
A log algorithm typically is one
where you cut the size of
the problem down by some
multiplicative factor.
You reduce it in half.
You reduce it in third.
All right?
Quadratic algorithms
tend to have this--
I was about to say additive,
wrong term-- but
doubly-nested, triply-nested
things are likely to be
quadratic or cubic algorithms,
all right, because you know--
let me not confuse things--
double-loop quadratic
algorithm, because you're doing
one set of things and
you're doing it some other
number of times, and that's a
typical signal that that's
what you have there.
OK.
And then the exponentials, as
you saw is when typically I
reduce the problem of one size
into two or more sub-problems
of a smaller size.
And you can imagine this gets
complex and there's lots of
interesting things to do to
look to the real form, but
those are the things that
you should see.
Now.
Two other things, before we
do this last example.
One is, I'll remind you, what
we're interested in is
asymptotic growth.
How does this thing grow as I
make the problem size big?
And I'll also remind you, and
we're going to see this in the
next example, we talked
about looking at

English: 
the worst case behavior.
In these cases there's no best
case worst case, it's just
doing one computation.
We're going to see an example
of that in a second.
What we really want to worry
about, what's the worst case
that happens.
And the third thing I want you
to keep in mind is, remember
these are orders of growth.
It is certainly possible, for
example, that a quadratic
algorithm could run faster
than a linear algorithm.
It depends on what the input is,
it depends on, you know,
what the particular cases are.
So it is not the case that,
on every input, a linear
algorithm is always
going to be better
than a quadratic algorithm.
It is just in general that's
going to hold true, and that's
what I want you to see.
OK.
I want to do one last example.
I'm going to take a little bit
more time on it, because it's
going to both reinforce these
ideas, but it's also going to
show us how we have to think
about what's a primitive
step., and in a particular,
how do data structures
interact with this analysis?
Here I've just been running
integers, it's pretty simple,
but if I have a data structure,
I'm going to have
to worry about that
a little bit more.
So let's look at that.

Korean: 
볼 것입니다. 
우리는 최악의 경우의 행동을 보고 얘기 해 보았습니다.
이러한 경우에서는 최고 혹은 최악의 경우란 없습니다. 
그것은 단지 계산을 할 뿐입니다. 우리는 그것의 예제를 두 번째로 볼 것입니다.
우리가 정말로 걱정하는 것은 최악의 경우의 것이 
일어나는 것입니다.
제가 여러분이 명심했으면 하는 세 번째 것은
이 성장의 순서를 기억하라는 것입니다. 
이것은 분명 가능합니다. 예를 들면 이 2차 알고리즘은
선형의 알고리즘보다 더 빨리 실행 될 수 있습니다. 
그것은 입력 값이 무엇인지에 달려 있습니다. 그것은 여러분이 알다시피,
특정 경우에도 의존합니다. 
그래서 그것이 그 경우가 아니라면, 모든 입력값에
선형 알고리즘은 항상 2차 알고리즘 은 나아질 것입니다.
그것은 단지 일반적으로 사실을 갖게 될 것이고, 그것이 바로 
제가 여러분이 봤음 하는 것입니다. 
좋아요.
마지막 예제를 한번 해 보겠습니다. 
그것을 하는 데는 좀 더 시간이 걸릴 겁니다. 
왜냐하면, 이것은  그 생각들을 둘 다 강화시킬 것입니다. 하지만 
또한 우리에게 초기단계가 무엇인지 생각해보는 방법을 보여 줄 것입니다. 
그리고  특별히 데이터 구조가 이 분석과 
어떻게 상호작용을 하는지에 대해서도요. 
여기 정수타입들을 실행시켜 보았습니다. 꽤 간단합니다. 
하지만 만약 제가 데이터 구조를 갖는다면 
조금 더 걱정을 해 봐야 할 것입니다.
자 이제 그것을 한번 봅시다. 

English: 
And the example I want to look
at is, suppose I want to
search a list that I know is
sorted, to see if an element's
in the list. OK?
So the example I'm going to
do, I'm going to search a
sorted list. All right.
If you flip to the second side
of your handout, you'll see
that I have a piece of code
there, that does this-- let
me, ah, I didn't want to
do that, let me back up
slightly-- this is the algorithm
called search.
And let's take a look at it.
OK?
Basic idea, before I even look
at the code, is pretty simple.
If I've got a list that is
sorted, in let's call it, just
in increasing order, and I
haven't said what's in the
list, could be numbers, could
be other things, for now,
we're going to just assume
they're integers.
The easy thing to do would be
the following: start at the
front end of the list, check
the first element.
If it's the thing I'm looking
for, I'm done.
It's there.
If not, move on to
the next element.
And keep doing that.

Korean: 
그리고 제가 보고 싶은 예가 있는데, 분류가 된 것을 알고 있는 리스트를 찾길 원한다고 가정하는 것입니다.
그 요소가 그 리스트 안에 있는지 
보려고요. 
됐나요?
그래서 제가 하려고 하는 그 예는 
분류된 리스트를 검색해 볼 것입니다. 
좋아요. 
만약, 여러분이 여러분의 출력물을 다음 면으로 접는다면,
여러분은 거기에 제가 가진 코드의 조각들을 볼 수 있을 것입니다. 
그것이 바로 이것과 같죠. 아 저는 그것을 하길 원한 건 아닙니다. 
제가 다시 돌아가게 해주십쇼 – 이것은 검색이라고 불리는 알고리즘입니다.
그리고 이것을 한번 봅시다. 
됐나요?
제가 심지어 이 코드를 보기 전에 기본적인 아이디어는 꽤 간단합니다. 
만약 분류가 된 리스트를 갖고 있다면 한번 호출해 봅시다.
순서가 증가하는 쪽으로요. 그리고 저는 아직 리스트 안에 무엇이 있는지 
말한 적이 없습니다. 숫자가 될 수도 있고,
다른것이 될 수도 있습니다.
다음 알려줄 것이 하기 쉬울거예요.
서론에서 시작을 하고 리스트에서 끝납니다, 첫번째 요소를 확인하세요.
만약 그것이 내가 보고있는것이라면, 저는 다 했습니다.
여기보세요.
만약 이게 아니라면, 다음 것으로 넘어가보죠.
계속해서 이런식으로 해보세요.

English: 
But if, at any point, I get to
a place in the list where the
thing I'm looking for is smaller
than the element in
the list, I know everything else
in the rest of the list
has to be bigger than that,
I don't have to
bother looking anymore.
It says the element's
not there.
I can just stop.
OK.
So that's what this piece
of code does here.
Right.?
I'm going to set up a variable
to say, what's the answer I
want to return, is
it there or not.
Initially it's got that
funny value none.
I'm going to set up an index,
which is going to tell me
where to look, starting at the
first part of the list, right?
And then, when I got--
I'm also going to count how many
comparisons I do, just so
I can see how much work
I do here, and then
notice what it does.
It says while the index is
smaller than the size of the
list, I'm not at the end of the
list, and I don't have an
answer yet, check.
So I'm going to check to see
if-- really can't read that
thing, let me do it this way--
right, I'm going to increase
the number of compares, and I'm
going to check to say, is
the thing I'm looking for at
the i'th spot in the list?
Right, so s of i saying, given
the list, look at the i'th

Korean: 
그런데 만약, 어느 시점에서, 
내가 보는 것이 리스트에 있는 요소보다 더 작은 것을 보게된다면,
그때는 그 리스트의 나머지 것들은 그것보다 더 크다는 것을 알게되는 것이죠.
그 밖에 것들은 볼 필요가 없게되는 겁니다.
그것은 요소가 거기에 없다는 것입니다. 
그만 해도 되는 거죠. 
좋아요. 
그래서 이것이 바로 이 코드의 조각이 여기서 하는 것입니다.
맞나요? 
저는 변수를 설정할 것입니다. 제가 리턴하고 싶은 답이
거기인지 아닌지를 저장하는 변수이죠.
첫 번째로 그것은 어떤값도 갖지않죠. 
저는 이제 인덱스를 설정할 것입니다. 그것은 제게 리스트의 첫 부분에서 시작하여
어딜 보는지 말해 줄 것입니다. 맞나요?
그리고 나서 –저는 또한 제가 하고 있는 것의 비교가 얼마나 많은지
여기서 제가 하고 있는 일의 양이 어느 정도인지 보기 위하여 세어 볼 것입니다. 
그리고 나서 그것이 하는 것을 보고 
리스트의 사이즈보다 인덱스가 더 작을 동안, 
리스트에 끝에 있는 것이 아닐 것이며 아직 답을 갖지 못할 것입니다. 
확인해 볼까요?
그래서 저는 이것을 확인해보려 – 정말 그건 못 읽겠네요.
이것은 제가 하겠습니다- 좋습니다. 저는 비교하는 횟수를
늘려보겠습니다. 그리고 나서 확인해보면 
그 리스트에서 i번째 부분에서 찾고 있는 그것이 맞나요? 
맞습니다. 그래서 s(i)는 주어진 리스트에서 i번째 요소를 

English: 
element, is it the same thing?
If it is, OK.
Set the answer to true.
Which means, next time through
the loop, that's going to pop
out and return an answer.
If it's not, then check to see,
is it smaller than that
element in the current
spot of the list?
And if that's true, it says
again, everything else in the
list has to be bigger than this,
thing can't possibly be
in the list, I'm taking
advantage of the ordering, I
can set the answer to false,
change i to go to the next
one, and next time through the
loop, I'm going to pop out and
print it out.
OK?
Right.
Order of growth here.
What do you think?
Even with these glasses on,
I can see no hands up, any
suggestions?
Somebody help me out.
What do you think the order
of growth is here?
I've got a list, walk you
through it an element at a

Korean: 
보고 있다는 것입니다. 같은 것인가요?
만약 그렇다면, 좋아요.
답이 사실이 되도록 설정해봅시다. 
그 뜻은 다음에 루프를 돌릴 때, 그것은 답이
나오고 리턴한다는 뜻입니다. 
만약 그것이 아니라면 한번 확인해 봅시다. 그것은
현재 그 리스트의 지점에 있는 요소보다 작습니까? 
그리고 만약 그렇다면, 다시 말하자면 그  리스트의 나머지 모든 것은 
이것보다 커야 한다는 것이고  그것은 리스트에 아마도 존재 할 수 없을 것입니다. 
오더링의 이점을 사용하여, 
답을 거짓으로 설정하고 i를 다음 것으로 가게 바꿉니다. 
그리고 다음 번 루프를 돌릴 때, 툭 튀어나오고 
출력될 것입니다.
알겠나요? 
좋습니다.
여기 성장의 순서가 있습니다.
어떻게 생각하나요?
심지어 이런 안경을 꼈는데도 손드는 사람이 아무도
안보이네요. 제안 없습니까?
누구라도 절 도와주세요 
여기에서 성장순서에 대해 어떻게 생각하나요? 
리스트가 있습니다. 한번에 한 개의 요소를 볼 수 있게 합니다.

Korean: 
한번보다 더 리스트의 각 요소들을 보고  있나요? 
아닌 것 같은데 맞나요? 
그럼 다른 생각 없습니까?
뭐라구요?
상수요. 
그것은 리스트의 길이에 상관없다는 뜻이죠.
저는 같은 시간이 걸리겠네요. 
그리고  저는 그게 사실이라고 생각하지 않습니다. 맞나요?
만약 제가 10배 더 긴 리스트가 있다면 그것은 
더 오래 걸릴 거에요. 하지만 나쁜 추측은 아닙니다.
전 여전히 학생을 칭찬합니다. 감사합니다.
또누구 없나요? 
네 
선형입니다.
왜죠? 
학생이 맞아요. 그런데 왜입니까? 
네 
맞습니다. 그래서 답은 선형입니다. 
아주 명백히 맞는 답이죠.
이유가 뭐든 우리는 다시 두 번째에 보게 될 것입니다.
오 감사합니다. 여러분의 친구들이 그것에 대하여 여러분을 도와주길 바랍니다.
감사합니다.
맞나요? 
여러분은 여기서 선형으로 볼 수 있습니다. 왜냐하면 
저는 지금 무엇을 하고 있나요?
리스트를 따라 내려가고 있습니다. 
제가 말하지 않았던 것들 중 하나는  여기서 내포된 것의 종류인데 
그것은,그 문제의 사이즈를 측정하는 것은 
무엇인가 입니다. 

English: 
time, do I look at each
element of the
list more than once?
Don't think so, right?
So, what does this suggest?
Sorry?
Constant.
Ooh, constant says, no matter
what the length of the list
is, I'm going to take the
same amount of time.
And I don't think that's
true, right?
If I have a list ten times
longer, it's going to take me
more time, so-- not a
bad guess, I'm still
reward you, thank you.
Somebody else.
Yeah.
Linear.
Why?
You're right, by the
way, but why?
Yeah.
All right, so the answer was
it's linear, which is
absolutely right.
Although for a reason
we're going to
come back in a second.
Oh, thank you, I hope your
friends help you out with
that, thank you.
Right?
You can see that this
ought to be linear,
because what am I doing?
I'm walking down the list. So
one of the things I didn't
say, it's sort of implicit here,
is what is the thing I
measuring the size of
the problem in?

Korean: 
리스트의 사이즈는 무엇인가요? 
그리고 만약 제가 리스트를 따라 내려간다면 이것은 아마 
리스트 S의 길이의 순서 가 될 것입니다. 왜냐하면 한번에
한 개의 요소를 보고 있기 때문이죠
이제 여러분은 아마도 잠깐만 기다리라고 말할 것입니다.
문제들은 순서가 정해졌죠. 만약 그것들의 도중에 제가 멈추고
그 리스트의 반절을 버린다면 그것은 제게 도움이 되지 않을 까요? 
그리고 그 답은 네입니다. 하지만 그것의 복잡성을 바꾸지는 않습니다.
왜냐하면 우리가 뭐라고 했었죠?
우리는 지금 최악의 경우를 측정하고 있습니다.
여기서 최악의 경우는 리스트에 그 값이 없는 경우인데, 
그 경우에는 우리가 리스트의 끝에 도착할 때까지
모든 것을 봐야합니다.
좋아요.
이제 그것을 말했고, 이제 저는 두 번째에서 
다시 돌아가야 하는 것에서 약간의 실질적인 미묘함을 갖고 있습니다. 
이것을 행하는 데 있어서 더 좋은 방법일 것입니다. 
맞나요?
그리고 여기 생각해보기에 더 좋은 방법이 있습니다.
저는 리스트의 웃긴 묘사의 종류를 그려보겠습니다. 
이것은 세포의 종류입니다.
만약 여러분이 원한다면 메모리안에 리스트의 요소들을 잡고 있는 것입니다.

English: 
What's the size of the list?
And if I'm walking down the
list, this is probably order
of the length of the list s,
because I'm looking at each
element once.
Now you might say,
wait a minute.
Thing's ordered, if I stop part
way through and I throw
away half the list, doesn't
that help me?
And the answer is yes, but it
doesn't change the complexity.
Because what did we say?
We're measuring the
worst case.
The worst case here is, the
things not in the list, in
which case I've got to go all
the way through the list to
get to the end.
OK.
Now, having said that, and I've
actually got a subtlety
I'm going to come back to in a
second, there ought to be a
better way to do this.
OK?
And here's the better
way to think about.
I'll just draw out sort of a
funny representation of a
list. These are sort of the
cells, if you like, in memory
that are holding the elements
of the list. What we've been

Korean: 
우리가 말해왔던 것은 저는 여기에서 시작하고 봅니다.
만약 거기라면 저는 다 끝났습니다.
만약 아니라면, 거기로 갑니다.
만약 거기라면 저는 끝났습니다. 아니라면, 계속 내려가서 
제가 찾고 있는 그 요소가 리스트 안의 값보다 
작은 지점에 도착했을 때에 멈춥니다. 이것의 나머지가
너무 크다는 것을 알 경우에는 멈출 수 있습니다.
하지만 여전히 그 리스트를 통과해야만 하죠
이것에 더 좋은 방법이 있는지 생각해보세요. 
사실 구탁교수님은 이미 저번 마지막 두 강의에서 
이것의 힌트를 주셨습니다. 
더 좋은 방법은 처음에서 시작하는 것이
더 낫다고 가정해보세요. 이처럼 무작위로 
몇 부분을 쥔다고 생각해보십쇼.
그리고 그 값을 봅니다
만약 제가 찾고 있는 값이 있다면 오 저는
베가스로 가야하겠죠. 전 정말 운이 좋으니깐요. 
그리고 전 다 했습니다. 맞죠?
만약 아니라면, 제가 무엇을 할 수 있나요?
음 여기서 그 값을 볼 수 있습니다. 그리고 제가 찾으려고 하는 그 값에
그것을 비교해 봅시다. 그리고 다음을 말합니다. 만약 제가 찾고 있는 그 값이
이 값보다 크다면 제가 봐야만 하는 곳이
어디입니까? 
바로 여기입니다. 
맞나요?
거기서부터는 가능하지 않습니다.

English: 
saying is, I start
here and look.
If it's there, I'm done.
If not, I go there.
If it's there, I'm done, if not,
I keep walking down, and
I only stop when I get to a
place where the element I'm
looking for is smaller than
the value in the list., in
which case I know the
rest of this is too
big and I can stop.
But I still have to go
through the list.
There's a better way to think
about this, and in fact
Professor Guttag has already
hinted at this in the last
couple of lectures.
The better way to think about
this is, suppose, rather than
starting at the beginning, I
just grabbed some spot at
random, like this one.
And I look at that value.
If it's the value I'm looking
for, boy, I ought to go to
Vegas, I'm really lucky.
And I'm done, right?
If not, what could I do?
Well, I could look at the value
here, and compare it to
the value I'm trying to find,
and say the following; if the
value I'm looking for is bigger
than this value, where
do I need to look?
Just here.
All right?
Can't possibly be there,
because I know

English: 
this thing is over.
On the other hand, if the value
I'm looking for here--
sorry, the value I'm looking for
is smaller than the value
I see here, I just need
to look here.
All right?
Having done that, I could do the
same thing, so I suppose I
take this branch, I can pick a
spot like, say, this one, and
look there.
Because there, I'm done,
if not, I'm either
looking here or there.
And I keep cutting
the problem down.
OK.
Now, having said that, where
should I pick to
look in this list?
I'm sorry?
Halfway.
Why?
You're right, but why?
Yeah.
So the answer, in case you
didn't hear it, was, again, if
I'm a gambling person, I could
start like a way down here.
All right?
If I'm gambling, I'm saying,
gee, if I'm really lucky,

Korean: 
왜냐하면 이 것은 끝날 것이라는 것을 알기 때문입니다.
반면에, 만약 여기서 제가 찾는 값이 –미안합니다,
제가 찾고 있는 값은 제가 여기서 보고있는 값보다 작습니다. 
저는 단지 여기서 단지 보는 것이 필요할 뿐이죠.
맞나요?
그것을 다하고 난 뒤, 저는 같은 것을 할 수 있습니다. 
그래서 제가 이 가지를 가졌다고 가정해보죠. 저는 말하자면 이것과 같은 점을 찍을 수 있습니다.
저기를 보세요. 
왜냐하면 저기에서, 전 다 했습니다. 만약 아니라면 
저는 또한 여기 혹은 저기를  봅니다.
그리고 저는 그 문제를 잘라내기를  계속 합니다.
좋아요. 
이제 말한 것과 같이 이 리스트에서 찾기위해 
어디를 골라야 하나요?
뭐라구요? 
반절요? 
왜요? 
학생이 맞습니다. 하지만 왜일까요? 
네. 
대답과 같습니다. 여러분이 그것을 못 들은 경우가 있으니 다시 말하자면. 만약
제가 도박꾼입니다. 그럼 저는 바로 여기에서 이것과 같이 시작할 수 있습니다. 
맞나요? 
만약 제가 도박을 한다면. 저는 gee 라고 말하고 제가 만약 운이 정말 좋다면, 

Korean: 
이쪽 면에만 있을 것입니다. 그리고 제가 할 것이 조금 있네요. 
하지만 제가 운이 좋지 않다면 저는 망했습니다.
망한것의 대과거형입니다. 좋아요. 아니면 boston fish죠.
이제 저는 그 리스트의 큰 덩어리의 나머지 부분을 보겠습니다. 
그리고 그것은 고역이네요. 
그래서 반절로 나누는 것은 우리가 해야하는 올바른 것입니다. 
왜냐하면 각 단계에서 저는 최소한 리스트의 절반을 버릴 수 있다는 것을 보장합니다. 
맞나요?
아주 좋네요.
좋아요. 
여기에서 여러분은 성장순서를  어떻게 추측할 수 있나요.
네.
왜죠?
좋네요 
정확합니다. 
맞나요?
여러분이 못 들었을 경우에 다시 말하자면, 답은 바로 로그입니다.
왜냐하면 저는 매번 문제들을 반으로 잘라냈기 때문입니다. 
학생이 맞습니다. 하지만 거기에는 우리가 추가적으로 해야하는 것들이 있습니다. 
그리고 제가 하고싶어하는 것의 마지막 것입니다.
좋아요.
이제 코드를 한번 봅시다. 실제로, 우리가 그것을 해보기 전에
먼저 이것을 테스트 해봅시다. 
그래서 제가 이것을 추가했습니다. 구탁교수님이 했던 것처럼요. 아. 
이런 방법으로 말했어야 하는 군요. 이것을 위해 먼저 코드를 써 봅시다. 미안합니다 – 
좋아요. b검색이라 불리는 것의 
조금을 써 보겠습니다. 
저는 바로 여기에서 이 검색으로 호출을 할 것이고 

English: 
it'll be only on this side, and
I've got a little bit of
work to do, but if I'm unlucky,
I'm scrawed, the past
pluperfect of screwed, OK.,
or a Boston fish.
I'll look at the rest of that
big chunk of the list, and
that's a pain.
So halfway is the right thing
to do, because at each step,
I'm guaranteed to throw away at
least half the list. Right?
And that's nice.
OK.
What would you guess the order
of growth here is?
Yeah.
Why?
Good.
Exactly.
Right?
Again, if you didn't hear it,
the answer was it's log.
Because I'm cutting down the
problem in half at each time.
You're right, but there's
something we have to do to add
to that, and that's the last
thing I want to pick up on.
OK.
Let's look at the code--
actually, let's test this out
first before we do it.
So I've added, as Professor
Guttag did-- ah, should have
said it this way, let's write
the code for it first, sorry
about that--
OK, I'm going to write a little
thing called b search.
I'm going to call it down here
with search, which is simply

English: 
going to call it, and then
print an answer out.
In binary search-- ah, there's
that wonderful phrase, this is
called a version of binary
search, just like you saw
bin-- or bi-section methods,
when we were doing numerical
things-- in binary search, I
need to keep track of the
starting point and the
ending point of the
list I'm looking at.
Initially, it's the beginning
and the end of it.
And when I do this test, what I
want to do, is say I'm going
to pick the middle spot, and
depending on the test, if I
know it's in the upper half, I'm
going to set my start at
the mid point and the end stays
the same, if it's in the
front half I'm going to keep
the front the same and I'm
going to change the endpoint.
And you can see that
in this code here.
Right?
What does it say to do?
It says, well I'm going to print
out first and last, just
so you can see it, and then I
say, gee, if last minus first
is less than 2, that is, if
there's no more than two
elements left in the list, then
I can just check those
two elements, and return
the answer.
Otherwise, we find
the midpoint, and
notice what it does.
First, it's pointing to the
beginning of the list, which
initially might be down here at
0 but after a while, might
be part way through.

Korean: 
아주 단순하게 호출됩니다. 그리고 나서 답을 출력시키죠.
이분법 검색에서는 – 아, 여기에는 아주 훌륭한 문구가 있습니다. 
이것은 이분검색의 버전으로 불리는데 여러분이 숫자와 관련된 것을 행할 때, bin 
혹은bi –section 도구에서 본 것과 같은 것입니다.- 
이분법 검색에서는 제가 보고 있는 그 리스트의 시작점과
끝 지점의 트랙을 유지해야만 합니다. 
처음에, 그것은 그것의 처음과 끝입니다. 
그리고 제가 이 테스트를 할 때, 제가 하길 원하는 것은 말하자면,
중간부분을 골라 그 테스트에 의존하는 것입니다. 만약 그것이 
그 반절의 윗부분에 있다는 것을 제가 안다면, 저는 
중간부분을 제 시작점으로 맞추고 끝부분은 똑같이 남겨둘 것입니다. 만약 앞쪽에 있다면 
앞쪽을 똑같이 남겨두고 끝 지점을
바꿀 것입니다. 
그리고 여러분은 여기 이 코드 안에서 그것을 볼 수 있습니다.
좋아요. 
이제 무엇을 하라고 하나요?
음 저는 이제 처음과 끝을 출력할 것이고 
여러분은 그것을 볼 수 있습니다. 그리고 나서 저는 감탄할 것이고 만약
끝 값에서 처음 값을 뺀 값이 2보다 작다면, 만약 그 리스트 안에 남은 요소가 
2개보다 더 많다면 저는 그 2가지 요소들을 확인할 수 있습니다. 
그리고 값을 리턴합니다.
반면에, 우리는 중간 지점을 찾아 
그것이 무엇인지 압니다. 
먼저 그것은 리스트의 시작점을 가리키고 그것은 
처음에는 여기에 있을 것이지만 좀 지난 후에는 아닐 것입니다.
아마 중간 지점 정도겠지요. 

Korean: 
그리고  거기에서 저는 아주 단순하게 절반 지점을 추가합니다. 
그리고 나서 확인합니다.
만약 그 지점에 있다면, 저는 다 끝났습니다. 만약 아니라면,
만약 그것이 제가 찾고 있는 값보다 크다면, 저는 또 다른 반
혹은 다른 것을 해야 합니다.
좋아요.
여러분은 매번 문제를 반으로 잘라내는 것을
볼 수 있습니다. 좋은 것이지만 거기에는 제가 다뤄야 하는 것이 
하나 이상이 있죠. 
그래서 좀 더 조심해서 이 단계를 밟아나가 봅시다.
그리고  우리가 이 것을 하기 전에 계속 말하고자 하는 것은 
단지 실제로 노력해보자는 것입니다. 
그래서 여기를 지나 갈 때, 저는 테트스 검색을 타이프할 것입니다. – 
전 타이프할수 있어요- 그리고 만약 여러분이 여러분의 출력물을 본다면, 그것은 
단지 제가 하려고 하는 테스트의 결과입니다.
좋아요.
그래서 첫 번째로, 저는 그 리스트를 
첫번째 백만 인티져가 되게 세팅할 것입니다. 
네, 간단하죠. 하지만 그것은 이것들의 리스트의 순서를  
주는 것과 같습니다. 한번 실행시켜 봅시다
좋아요. 
그래서 저는 처음에 리스트에 없는 어떤 것을  찾아 볼 것입니다. 
한번 보죠. 리스트의 마이너스 1이네요. 
이제 끝부분까지 가게 될 것이고 만약 기본적인 경우에서 
제가 이것을 한다면 됐네요.
끝입니다.
맞나요?
초기 검색에서(처음 요소를 보기 때문에 그렇게 불림) 기본은

English: 
And to that, I simply
add a halfway
point, and then I check.
If it's at that point, I'm done,
if not, if it's greater
than the value I'm looking
for, I either take
one half or the other.
OK.
You can see that thing is
cutting down the problem in
half each time, which is good,
but there's one more thing I
need to deal with.
So let's step through this
with a little more care.
And I keep saying, before
we do it, let's just
actually try it out.
So I'm going to go over
here, and I'm going
to type test search--
I can type-- and if you look at
your handout, it's just a
sequence of tests that
I'm going to do.
OK.
So initially, I'm going to set
up the list to be the first
million integers.
Yeah, it's kind of simple, but
it gives me an ordered list of
these things, And let's run it.
OK.
So I'm first going to look for
something that's not in the
list, I'm going to see, is minus
1 in this list, so it's
going to be at the far end,
and if I do that in
the basic case, bam.
Done.
All right?
The basic, that primary search,
because it looks at
the first element, says
it's smaller than

English: 
everything else, I'm done.
If I look in the binary case,
takes a little longer.
Notice the printout here.
The printout is simply telling
me, what are the
ranges of the search.
And you can see it wrapping its
way down, cutting in half
at each time until it
gets there, but it
takes a while to find.
All right.
Let's search to see though now
if a million is in this list,
or 10 million, whichever way
I did this, it must be a
million, right?
In the basic case, oh,
took a little while.
Right, in the binary
case, bam.
In fact, it took the same number
of steps as it did in
the other case, because
each time I'm cutting
it down by a half.
OK.
That's nice.
Now, let's do the following;
if you look right here, I'm
going to set this now to--
I'm going to change my range
to 10 million, I'm going to
first say, gee, is a
million in there,
using the basic search.
It is.
Now, I'm going to say, is 10
million in this, using the

Korean: 
다른 어떤 것보다 작다는 것입니다. 끝입니다.
만약 이분법의 경우에서 보자면, 조금 더 오래 걸립니다.
여기 이 출력 값은 보세요 
출력 값은 단순히 검색하려는 영역이 
무엇인지 말해줍니다. 
그리고 여러분은 그것이 쌓여있는 길을 보게 될 것입니다. 
거기에 도달하기 전까지 매번 반을 잘라내면서요. 그것은 찾기까지 시간이 좀 걸립니다. 
좋아요. 
만약 이 리스트에 백 만개 혹은 천 만개가 존재 한다면 
이제 어떻게 살펴볼 지 한번 검색해봅시다. 이것을 행하는 어떤 방법을 써도 
그것은 백만이겠네요. 맞나요? 
기본적인 경우에서, 오 잠깐의 시간이 걸립니다.
네, 이분법의 경우에서는 사실 그것은 다른 경우에서 한 것과 
같은 숫자의 단계가 걸립니다. 
왜냐하면, 각 시간마다 반절로 
나누기 때문이죠.
좋아요. 
아주 좋습니다.
자, 이제 이걸 한번 해 봅시다. 바로 여기를 한번 보면,
여기를 이렇게 세팅 할것입니다. – 제 영역을 
천만으로 바꿀 것입니다. 그리고 저는 처음 말할 것은 기본적 검색을 사용한다면, 
거기서 백만입니다. 
맞네요 
이제 저는 여기서 기본적 검색을 사용하여 

English: 
basic search.
We may test your hypothesis,
about how long does it take,
if I time this really well, I
ought to be able to end when
it finds it, which should
be right about now.
That was pure luck.
But notice how much
longer it took.
On the other hand, watch what
happens with binary.
Is the partway one there?
Yeah.
Is the last one there?
Wow.
I think it took one more step.
Man, that's exactly what
logs should do, right?
I make the problem ten times
bigger, it takes one
more step to do it.
Whereas in the linear case, I
make it ten times bigger, it
takes ten times longer to run.
OK.
So I keep saying I've got one
thing hanging, it's the last
thing I want to do, but I wanted
you see how much of a
difference this makes.
But let's look a little more
carefully at the code for
binary search-- for search 1.
What's the complexity
of search 1?
Well, you might say it's
constant, right?
It's only got two things to do,
except what it really says
is, that the complexity of
search 1 is the same as the
complexity of b search,
because that's
the call it's doing.

Korean: 
천만이라고 말할 것입니다. 
우리는 여러분의 가설들을 테스트해볼 수 있습니다. 
그것이 얼마나 걸릴지에 대해서요 만약 이것의 시간을 정말 잘 맞춘다면 
저는 아마 그것을 찾을 때의 끝을 알수 있겠죠. 
그것은 아주 운이 좋은 것일 겁니다.
하지만 그것이 얼마나 더 걸리게 될지 주목하세요.
반면에, 이분법을 사용하면 어떤 일이 일어나는지를 보세요. 
거기까지의 어느정도 인가요?
네
거기서 마지막 것인가요? 
와우. 
제 생각으로는 하나의 단계가 더 걸릴 것 같네요. 
그것이 바로 정확히 로그들이 되야하는 것이겠죠 맞죠? 
제가 이 문제를 10배 더 크게 만들겠습니다.
그것은 하나의 단계를 더 하게 만들 것입니다. 
선형의 문제가 있는 곳에서, 제가 10배 더 크게 만들겠습니다. 그것은 
실행시간을 10배 더 걸리게 만듭니다. 
좋아요.
그래서 제가 계속 말하고 있는 한가지는 제가 하고 싶어하는 마지막 것입니다. 
하지만 저는 여러분이 그것이 만들어 내는 차이가 
얼마나 큰지 보기를 원합니다. 
하지만 이분법 검색의 코드를 조금 더 주의 깊게 봅시다.
-1을 찾는 것을요 
1을 찾는 것의 복잡성은 무엇인가요?
음, 아마 여러분은 그것이 정수라고 말할 것입니다. 맞나요? 
그것은 단지 2가지의 할 것을 가집니다. 그것이 정말로 search1의 복잡성은
bsearch 복잡성과 같다고 말하는 것을 제외하구요. 
왜냐하면 그것은 지금 하고 있는 중인 호출이기 때문입니다. 

English: 
So let's look at b search.
All right?
We've got the code for
b search up there.
First step, constant, right?
Nothing to do.
Second step, hm.
That also looks constant,
you think?
Oh but wait a minute.
I'm accessing s.
I'm accessing a list. How long
does it take for me to get the
nth element of a list?
That might not be a
primitive step.
And in fact, it depends
on how I store a list.
So, for example, in this case,
I had lists that I knew were
made out of integers.
As a consequence, I have
a list of ints.
I might know, for example,
that it takes four memory
chunks to represent one
int, just for example.

Korean: 
자 그러니 bsearch을 한번 봅시다. 
됐나요? 
바로 저기에 bsearch을 위한 코드를 갖고 있습니다.
첫번째 단계에서는 상수입니다. 맞나요? 
할 일이 없네요.
두번째 단계입니다. 
그것 또한 상수로 보이네요. 그렇게 생각하나요?
오 하지만 잠깐 기다려보세요 
지금 s에 접근하고 있습니다.
리스트에요.
제가 리스트의 n번째 요소에 다다르게 하기 위해서 얼마나 걸리게 될까요?
그것은 초기 단계가 아닐 것입니다.
그리고 사실, 그것은 제가 리스트에 저장하는 방법에 달려 있습니다.
그리고 예를 들면, 이 경우에 인티져 타입으로 만들어진 것을 알고 있는 
리스트들을 갖고 있습니다. 
결과적으로 저는 정수타입의 리스트를 갖고 있습니다. 
전 아마도 알 수 있을 겁니다. 예를 들면, 그것은 하나의 정수를 대표하기 위해 
4개의 메모리 덩어리가 걸리게 될 것입니다. 단지 예를 들자면, 

Korean: 
i번째 요소를 찾기 위해 단지 시작점을 갖고 
리스트가 있는 메모리의 시작점에서 
i의 4배를 보면 거기에 가기  위해 
얼마나 많은 유닛이 있는지 말해 줄 것입니다. 
그것은 제가 찾고 싶은 그 리스트의 i번째 요소의 메모리 주소가 됩니다.
그리고 기억하세요. 우리는  무작위로 접근하는 모델을 가정할 것입니다. 
그것은 제가 그 위치를 알고 있는 한, 
그것은 그 지점까지 가는데 걸리는 변함 없는 시간의 양만큼 걸리게 할 것입니다. 
그래서, 만약 제가 단지 인티져 타입으로만 그 리스트가 이뤄졌다는 것은 안다면
그것을 알아내는 것은 매우 쉬울 것입니다. 
이것을 말하는 다른 방법은 이것은 찾아야 하는 곳을 알아내는 데 
변함 없는 시간의 양만큼 걸린다는 것입니다. 거기에 다다르기 까지요. 
그래서 사실, 저는 기본적인 절차로서
리스트에 인덱싱을 사용할 수 있습니다.
하지만, 우리는 리스트가 어떤 것으로든 
이뤄질 수 있다는 것을 합니다. 정수 타입이나, 실수 타입이 될 수 있죠. 
혹은 그 것의 조합이 될 수도 있구요. 정수와 실수와 배열,
스트링 뭐든지요. 
그리고 그 경우에, 일반적 리스트들에서는 접근 시간이

English: 
And to find the i'th element,
I'm simply going to take the
starting point, that point at
the beginning of memory where
the list is, plus 4 times i,
that would tell me how many
units over to go, and that's the
memory location I want to
look for the i'th element
of the list.
And remember, we said we're
going to assume a random
access model, which says, as
long as I know the location,
it takes a constant amount of
time to get to that point.
So if the-- if I knew the
lists were made of just
integers, it'd be really
easy to figure it out.
Another way of saying it is,
this takes constant amount of
time to figure out where to
look, it takes constant amount
of time to get there, so in fact
I could treat indexing
into a list as being
a basic operation.
But we know lists can be
composed of anything.
Could be ints, could be floats,
could be a combination
of things, some ints, some
floats, some lists, some
strings, some lists of
lists, whatever.
And in that case, in general
lists, I need to figure out

Korean: 
무엇인지 알아내는 것이 필요합니다.
그리고 여기서 저는 선택권이 있습니다. 
좋아요. 이 방법들 중 제가 할 수 있는 한가지는 다음과 같을 것입니다.
저는 여기의 첫 번째 요소가 실제 값을 갖는 리스트의 시작점을 가리키는
포인터를 가질 수 있습니다. 그리고 이것은 
그 리스트의 다음 요소를 가리키게 될것입니다. 
혹은 이것을 다르게 얘기하자면 그 부분의 첫 번째 파트는 
얼마나 많은 셀을 실제 값을 저장하기 위해 가져야 하는지의
몇몇 인코딩이 될 것입니다. 그리고 나서 저에겐 
그 리스트의 다음 요소를 갖기 위한 곳을 저에게  말해주는 몇몇 방법이 잇습니다.
그리고 이것은 값을 가리키는것이고, 이것은 메모리에서
어떤 곳을 가리키며 값을 가리킬 것입니다.
여기에, 그 기술을 가진 문제가 있습니다. 그런데, 
Lisp를 포함하여 여기에서는 수많은 프로그래밍 언어가 사용되었습니다. 
그 기술을 가진 문제는 아주 일반적이면서, 
제가 그 리스트의 i번째 요소를 찾기 위해서 
얼마나 긴 시간이 걸이나요?
오  
좋아요.
저는 이제 첫 번째 장소에 가서 건너뛰기 위해 얼마나 많은 것을

English: 
what's the access time.
And here I've got a choice.
OK, one of the ways I could
do would be the following.
I could have a pointer to the
beginning of the list where
the first element here is the
actual value, and this would
point to the next element in
the list. Or another way of
saying it is, the first part
of the cell could be some
encoding of how many cells do
I need to have to store the
value, and then I've got some
way of telling me where to get
the next element of the list.
And this would point to value,
and this would point off
someplace in memory.
Here's the problem with that
technique, and by the way, a
number of programming
languages use
this, including Lisp.
The problem with that technique,
while it's very
general, is how long does it
take me to find the i'th
element of the list?
Oh fudge knuckle.
OK.
I've got to go to the first
place, figure out how far over

Korean: 
지나야 할지 알아 낼 것이고, 두 번째 장소에 가서 또 알아볼 것입니다.
결국에는, 문 밖으로 나올 것입니다. 
저는 제가 가는 길을 셀 것이고 그것은 그 리스트의 i번째 요소를 찾기 위하여
리스트의 길이에서 선형으로 접근한다는 뜻입니다. 
그리고 그것은 복잡성을 
증가시킬 것입니다. 
대안법이 있는데, 그것은 제가 만들고 싶은 마지막 포인트이고, 
제가 할 수 있는 것의 대신입니다. 
이것들은 링크된 리스트라고 불린다고 말했어야 했는데 우리는 이것을 또 한번 볼 것입니다.
이것을 하기 위한 다른 방법은 
메모리의 어떤 장소에 있는 리스트의 시작점을 갖는 것입니다. 그리고 
실제적인 값들을 가리키는 메모리 안의 성공적인 셀들을 하나씩 보는 것입니다.
그것은 아마 몇몇의 임의적인 메모리의 양에서부터 시작 할 것입니다. 
그러한 경우에는 이 문제로 돌아옵니다. 
그리고 결과적으로 그 리스트에서 접근 시간은 변하지 않습니다. 
그것이 바로 제가 원하는 것이죠.
이제 내가 알기로는 대부분의 Python의 실행은 리스트들을 저장하는데 

English: 
to skip, go to the next place,
figure out how far over to
skip, eventually I'll
be out the door.
I've got to count my way down,
which means that the access
would be linear in the length
of the list to find the i'th
element of the list, and that's
going to increase the
complexity.
There's an alternative, which
is the last point I want to
make, which is instead what I
could do, I should have said
these things are called linked
lists, we'll come back to
those, another way to do it,
is to have the start of the
list be at some point in memory,
and to have each one
of the successive cells
in memory point off
to the actual value.
Which may take up some arbitrary
amount of memory.
In that case, I'm back
to this problem.
And as a consequence, access
time in the list is constant,
which is what I want.
Now, to my knowledge, most
implementations of Python use

English: 
this way of storing lists,
whereas Lisp
and Scheme do not.
The message I'm trying to get
to here, because I'm running
you right up against time, is
I have to be careful about
what's a primitive step.
With this, if I can assume
that accessing the i'th
element of a list is constant,
then you can't see that the
rest of that analysis looks just
like the log analysis I
did before, and each step, no
matter which branch I'm
taking, I'm cutting the
problem down in half.
And as a consequence,
it is log.
And the last piece of this, is
as said, I have to make sure I
know what my primitive elements
are, in terms of
operations.
Summary: I want you to recognize
different classes of
algorithms. I'm not going
to repeat them.
We've seen log, we've seen
linear, we've seen quadratic,
we've seen exponential.
One of the things you should
begin to do, is to recognize
what identifies those classes of
algorithms, so you can map
your problems into
those ranges.

Korean: 
이런 방법을 사용합니다. Lisp와 Scheme이 아닌 곳에서요.
내가 여기에서 여러분에게 말하고자 하는 것은 – 왜냐하면 제가 여러분을 시간에 상관없이
바로 실행시키고 있기 때문이죠- 초기 단계가 무엇인지에 대하여 
조심해야 한다는 것입니다. 
이것을 통해 만약 제가 어떤 리스트의 i번째 요소인 정수에 접근한다고 가정한다면
여러분은 제가 전에 했던 로그 분석처럼 보이는 
그 분석의 나머지를 볼 수 없습니다. 
그리고 각 단계에서 제가 갖는 가지에서 저는 반으로 
그 문제를 잘라내겠습니다. 
그리고 결과적으로 그것은 로그입니다.
그리고 이것의 마지막 조각은 말한 것과 같이 절차들 중간에
나의 초기 요소가 무엇인지 확실히 아는 것입니다.
요약: 저는 여러분이 알고리즘의 다른 수업들을
알기를 원합니다. 
저는 다시 그것들을 반복하지 않을 것입니다.
우리는 로그를 봐왔고, 선형을 봤고 이차와 지수를 봐왔습니다.
 
여러분이 시작해야 하는 것들 중 하나는
그 알고리즘 수업들이 무엇인지 알아야 합니다. 그래서 여러분은
그 영역에 여러분의 문제를 발견할 수 있습니다.

English: 
And with that, good
luck on Thursday.

Korean: 
목요일에 그 부분을 잘 이해하시길 바랍니다.
