
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 JOHN GUTTAG: OK.
I finished up last time
talking about lists.
And I pointed out that lists are
mutable, showed you some
examples of mutation.
We can look at it here; we
looked at append, which added
things to lists, we looked at
delete, deleting things from a
list. You can also assign to a
list, or to an element of a
list. So ivy sub 1, for example,
could be assigned

Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 다음 내용은 저작권으로 
보호되어 있습니다. 
MIT OCW(무료공개강좌) 는 계속해서 고품질의 교육자원을  
무료로 제공함으로써 여러분을 도와줄 것입니다. 
추가적인 MIT 코스의 자료를 보거나 
기부하시려면 ocw.mit.edu을 
방문해주세요.
존 구탁 교수 : 네. 
저는 지난 시간에 리스트에 대하여 말하면서 끝냈습니다. 
그리고 저는 리스트가 잘 변한다는 것을 지적했습니다, 
그리고 변화의 몇 가지 예를 여러분에게 보여 주었습니다. 
우리는 그것을 여기서 볼 수 있습니다 : 우리는 append 를 보았습니다,
그것은 리스트에 어떤 것을 더합니다, 우리는 리스트에서 어떤 것을 지우는 
delete 를 보았습니다,
여러분은 또한 리스트 또는 리스트의 요소에 지정 할 수도 있습니다. 
그래서, 예를 들어, ivy sub 1 은 마이너스 15 로 지정 될 수 잇습니다,

Korean: 
그리고 그것은 사실 리스트를 변화 시킵니다. 
그래서 지금까지, 우리가 문장을 쓰면서 우리가 항상 의미 
했던 것은, 변수의 바인딩을 다른 
객체로 바꾸는 것 입니다. 
여기서, 우리는 다음 표기 법을 오버로딩 할 것 입니다, 
아니요, 아니요, ivys 는 여전히 같은 객체이어야 합니다,
그러나 ivys 의 요소들은 다른 객체 이어야 합니다. 
만약 여러분이 그것에 대해 생각해 본다면 이해가 됩니다. 
왜냐하면 우리가 리스트를 가질 때, 리스트는 무엇이냐, 바로 객체의 순서 이기 때문 입니다. 
그리고 이것이 말하는 것은, 문장 ivys sub 1 에 의해 이름 붙여진 객체는 

English: 
minus 15, and that will actually
mutate the list.
So heretofore, when we wrote
assignment, what we always
meant, was changing the binding
of a variable to a
different object.
Here, we are overloading the
notation to say, no, no, ivys
is still bound to the same
object, but an element of ivys
is bound to a different
object.
If you think about it, that
makes sense, because when we
have a list, what a list is,
is a sequence of objects.
And what this says is, is the
object named by the expression

English: 
ivys sub 1, is now bound to the
object, if you will, named
by the constant minus 15.
So we can watch this run here.
Idle can-- that's exciting.
I hadn't expected that answer.
All right, your question.
STUDENT: [INAUDIBLE] four
elements to ivys, and you tell
it to change the fifth element
of ivys to negative 15, will
it add it or [INAUDIBLE]
PROFESSOR JOHN GUTTAG: Well,
I'll tell you how ol-- let's
answer that the easy way.
We'll start up a shell
and we'll try it.
All right, we'll just get out
of what we were doing here.

Korean: 
이제 객체이어야 한다는 것 입니다. 만약 여러분이 그렇게 한다면, 
정수 마이너스 15 에 의해 이름이 붙여 집니다. 
그래서 우리는 이것이 여기서 돌아가는 것을 볼 수 있습니다. 
이상적으로 – 그것은 흥미롭습니다. 
저는 그 답을 기대 하지 않았습니다. 
좋아요, 이 학생이 질문 하는군요. 
ivys 의 네 인자, 그리고 교수님은 그것을 ivys 의 5 번째 인자를 
마이너스 15 로 바꾸는 것 이라고 말씀하셨습니다, 그것을 더하거나 또는 ...
존 구탁 교수 : 자, 저는 여러분에게 말해보겠습니다. 
 – 그것을 쉬운 방법으로 답해 봅시다. 
우리는 쉘에서 시작할 것이고 그것을 시도할 것입니다. 좋아요, 
우리는 우리가 여기서 하고 있었던 것에서 나올 것 입니다. 

English: 
And so, we now have some things,
so we, for example,
have ivys, I can print ivys
, and it's only got three
elements but your question
probably is just as good for
adding the fourth as adding
the fifth, so what would
happen if we say ivys sub 3--
because that of course is the
fourth element, right?
Let's find out.
OK.
Because what that does is, it's
changing the binding of
the name ivys, in this
case, sub 1.
What it looked at here, with the
name ivys sub 3, and said
that name doesn't-- isn't
bound, right?
That isn't there.

Korean: 
그래서, 우리는 이제 어떤 것을 가지고 있습니다, 예를 들어, 우리는 ivys 를 가지고 있습니다, 
저는 ivys 를 출력 할 수 있습니다, 그리고 그것은 오직 3 인자를 가집니다
그러나 여러분의 답은 아마도 5 번째를 더하는 것 처럼 
4 번째를 더하는 것이 좋을 것입니다.
만약 우리가 ivys sub 3 을 말하면 무슨 일이 일어 날까요?
왜냐하면 수업의 그것은 네 번 째 인자 이기 때문 입니다. 그렇죠? 
한번 찾아 봅시다. 
좋습니다.
그것이 하는 일 때문에, 그것은 이름 ivys 의 바인딩을 바꿉니다, 
이 경우에는, sub 1 로요. 
그것이 여기서 보는 것은, 같은 이름 ivys sub 3 을 가지고, 
그리고 그 이름은 바운드가 아닌 것을 말합니다. 맞나요? 
그것은 거기 있지 않습니다. 

English: 
So it couldn't do it, so instead
that's what append is
for, is to stick things on to
the end of the list. But a
very good question.
So we can see what we did here,
and, but of course I can
now, if I choose, say something
like, ivys sub 1 is
assigned minus 15, and now if
I print ivys, there it is.
And again, this points out
something I wanted to me--
I mentioned last time, list can
be heterogeneous, in the
sense that the elements can be
multiple different types.
As you see here, some of the
elements are strings and some
of the elements are integers.
Let's look at another example.

Korean: 
그래서 그것은 그것을 할 수 없습니다, 그래서 대신에 그것이 append 가
그것을 위한 것은, 그것들을 리스트의 끝에 붙이는 것 입니다. 
그러나 매우 좋은 질문 입니다. 
그래서 우리는 우리가 여기서 했던 것을 볼 수 있습니다, 
물론 이제 저는 할 수 있습니다, 만약 제가 선택한다면요, 저는 다음과 같이 말할 수 있습니다, 
'ivys sub 1 은 마이너스 15 로 지정 되었다' 이제 만약 제가 ivys 를 출력 하면, 그것이 있네요. 
그리고 다시, 이것은 제가 원했던 것을 저에게 지적 합니다. 
저는 지난 시간에 언급 했습니다, 리스트는 여러 다른 종류들로 이뤄진 것 입니다, 
그 의미에서 요소들은 다양한 다른 타입일 수 있습니다. 
여러분이 여기서 보는 것 처럼, 요소들 중 
몇 가지는 문자열이고 요소들 중 몇 가지는 인티져 입니다. 
이제 또 다른 예를 살펴 봅시다. 

English: 
Let's suppose, we'll start
with the list,
I'll call it l 1.
This, by the way, is a really
bad thing I just did.
What was-- what's really bad
about calling a list l 1?
STUDENT: [INAUDIBLE]
PROFESSOR JOHN GUTTAG: Is it l
1, or is it 11, or is it l l?
It's a bad habit to get into
when you write programs, so I
never use lowercase L except
when I'm spelling the word
where it's obvious, because
otherwise I get all sorts of
crazy things going on.
All right, so let's make
it the list 123.
All right?
Now, I'll say L 2 equals L 1.
Now I'll print L 2.
Kind of what you'd guess, but
here's the interesting

Korean: 
가정해봅시다. 리스트에서 시작해, 저는 그것을 l 1 이라고 부를 것 입니다. 
이것은, 그런데, 정말 제가 했던 나쁜 것 입니다. 
그것은 – 리스트를 l 1 이라고 부르는 것은 무엇이 정말 나쁜 가요? 
교수 : 그것은 l 1 입니까 아니면 11 입니까, 아니면 l l 입니까? 
여러분이 프로그램을 쓸 때, 그렇게 하는 것은 나쁜 습관 입니다. 
그래서 저는 소문자 L 을 절대 사용하지 않습니다, 
명백히 필요한곳에서 단어의 철자를 쓸 때를 제외하고는요. 
그렇지 않으면 이상한 일들이 계속 되기 때문 입니다. 
좋아요, 그래서 그것을 리스트 123 이라고 해 봅시다. 
알겠죠? 
이제, 저는 L 2 가 L 1 과 같다고 말할 것 입니다. 
이제 저는 L 2 를 출력 할 것 입니다. 
여러분이 추측한 것 입니다. 그러나 여기 흥미로운 질문이 있습니다 : 

English: 
question: if I say L 1 is
assigned 0, L 1 sub 0 is
assigned 4, I'll print L 1.
That's what you expect, but
what's going to happen
if I print L 2?
423 as well, and that's because
what happened is I had
this model, which we looked at
last time, where I had the
list L 1, which was bound to
an object, and then the
assignment L 2 gets L 1, bound
the name L 2 to the same
object, so when I mutated this
object, which I reached

Korean: 
만약 제가 L 1 을 0 으로 지정한다고 말하면, L 1 sub 는 4 입니다.
저는 L 1 을 출력 할 것 입니다. 
그것은 여러분이 기대 한 것 입니다, 
그러나 만약 제가 L 2 를 출력 하면 무슨 일이 일어 날까요? 
또한 423 입니다. 왜냐하면 그것은 일어난 일이 우리가 저번 시간에 
보았던 이 모델을 제가 갖고 있기 때문입니다. 
객체여야만 하는 리스트 L 1 을 가지는 곳에서 말이죠 .
그리고 나서 L 2 는 L 1 을 얻습니다, 이름 L 2 는 같은 객체 여야 합니다.

Korean: 
그래서 제가 이 객체를 변경할 때, 저는 이름 L 1 을 통해 그 4를 만드는데 도달합니다.
왜냐하면 이 이름은 같은 객체이어야 하기 때문 입니다. 
제가 그것을 출력 할 때, 저는 423 을 얻습니다. 
그래서 그것은 핵심 사항 입니다 – 깨달아야 하는 핵심 사항입니다 : 
대입이 한 것은 두 분리된 경로를 
같은 객체로 만든 것 입니다. 
그래서 저는 이 길을 통해서 또는 그 길을 통해서 그 객체로 갈 수 있습니다.
제가 그것을 수정하기 위해 어떤 길을 사용하는지는 중요하지 않습니다. 
저는 다른 것을 볼 때 그것을 볼 것 입니다.  
네.
교수 : 그래서 질문은, 만약 제가 a 에 2 를 대입 한다고 말하면,
 b 는 a 를 대입 합니다. 그리고 나서 a 는 3 을 대입 합니다. 
이것이 학생의 질문 인가요?  

English: 
through the name L 1 to make
that 4, since this name was
bound to the same object, when
I print it, I got 423.
So that's the key thing to--
to realize; that what the
assignment did was
have two separate
paths to the same object.
So I could get to that object
either through this path or
through that path, it didn't
matter which path I use to
modify it, I would see it when
I looked at the other.
Yes.
STUDENT: [INAUDIBLE]
PROFESSOR JOHN GUTTAG: So the
question, if I said a is
assigned 2, b is assigned a,
and then a is assigned 3.
Is that your question?

English: 
So the question is, a is
assigned 1, b is assigned a, a
is assigned 2, and then if
I print b, I'll get 1.
Because these are not mutable,
this is going to be assigned
to an object in the store, so
we'll draw the picture over
here, that we had initially a
is bound to an object with 1
in it, and then b got bound to
the same object, but then when
I did the assignment, what that
did was it broke this
connection, and now had a
assigned to a different

Korean: 
그래서 질문은, a 에 1 를 대입 하고, b 는 a 를 대입 합니다. 
a 는 2 를 대입 합니다. 그리고 나서 제가 b 를 출력 하면, 저는 1 을 얻을 것 입니다. 
왜냐하면 변하지 않기 때문 입니다. 이것은 저장된 객체에 대입 될 것 입니다.
그래서 우리는 여기서 그림을 그릴 것 입니다.
우리가 초기에 a 를 가진 것은 그 안에 1 을 가진 객체 이어야 합니다.
그리고 나서 b 를 같은 객체에 가져야 합니다.
그러나 제가 대입을 했을 때, 그것이 했던 것은 그것이 이 연결을 깬 것입니다.  
다른 객체에 대입 했습니다.

Korean: 
숫자에요, 이 경우에는 그것에 2 를 대입 했습니다. 
반면에 여러분이 여기서 보는 리스트 대입은 객체 l 1 을 다시 묶지 않았습니다.
그것은 이것을 바꿨습니다.
맞죠?
이제 공식적으로 저는 4 를 포함 하는 또 다른 객체에 점을 찍는 이것을 
가졌어야 했습니다. 그러나 그것은 초과한 것으로 보이지 않습니다. 네? 
그러나 여러분은 차이를 알 수 있습니다. 
좋은 질문 입니다. 그리고 이해해야하는 매우 중요한 것입니다.
그리고 그것은 제가 이 점을 다시 보는 이유입니다, 
왜냐하면 이것이 학생들이 매우 혼란스러워 하는 부분이기 때문입니다. 
그리고 이것은 변화를 이해하는데 매우 중요한 부분이기 때문입니다. 
네. 
교수 : 저는 그것이 좋은 질문일것이라고  
가정 할 것 입니다.
교수 : 정확 합니다. 

English: 
object, with the number,
in this case, 2 in it.
Whereas the list assignment you
see here did not rebind
the object l 1, it
changed this.
OK?
Now formally I could have had
this pointing off to another
object containing 4, but that
just seemed excessive, right?
But you see the difference.
Great question, and a very
important thing to understand,
and that's why I'm belaboring
this point, since this is
where people tend to get pretty
confused, and this is
why mutation is very important
to understand.
Yeah.
STUDENT: [UNINTELLIGIBLE]
PROFESSOR JOHN GUTTAG:
I'm just assuming
it'll be a great question.
STUDENT: [INAUDIBLE]
PROFESSOR JOHN GUTTAG:
Exactly.

English: 
So if-- very good question-- so,
for example, we can just
do it here.
The question was, suppose I now
type L 1 equals the empty
list. I can print L 1, and I can
print L 2, because again,
that's analogous to this
example, where I just swung
the binding of the identifier.
So this is important, it's a
little bit subtle, but if you
don't really understand this
deeply, you'll find yourself
getting confused a lot.
All right?
OK.
Let me move on, and I want to
talk about one more type.

Korean: 
그래서 만약 – 매우 좋은 질문이에요 – 그래서, 예를 들어, 
우리가 그것을 여기에서 할 수 있습니다. 
질문은, 제가 이제 타입 L 1 이 빈 리스트와 같다고 타이프 한다고 가정해 보세요. 
저는 L 1 을 출력 할 수 있고 저는 L 2 를 출력 할 수 잇습니다.
왜냐하면 다시, 그것은 이 예와 유사하기 때문 입니다.
거기서 저는 식별자의 묶음을 움직 입니다.
그래서 이것은 중요 합니다. 그것은 약간 미묘해서,
만약 여러분이 정말 이것을 깊이 이해하지 않으면, 
여러분은 무척 혼란스러워 할 것입니다. 
알겠죠?
좋습니다.
더 나아가 볼까요? 저는 한 가지 더 타입을 이야기 하고 싶습니다. 

English: 
By the way, if you look at the
handout from last time, you'll
see that there's some other
examples of mutation,
including a function
that does mutation.
It's kind of interesting, but I
don't think we need-- think
we've probably done
enough here that I
hope it now make sense.
That one type I want to talk
about still is dictionaries.
Like lists, dictionaries are
mutable, like lists, they can
be heterogeneous, but unlike
lists, they're not ordered.

Korean: 
그런데, 만약 여러분이 지난 시간의 핸드 아웃을 보면, 
여러분은 변화의 어떤 다른 예들이 있는 것을 볼 수 있습니다.
변화하는 함수를 포함해서요. 
그것은 흥미로운 것이지만, 저는 우리가 해야한다고 생각하지 않습니다.
우리는 여기서 충분히 했기 때문에 아마 이제 이해가 가길 바랍니다.
제가 여전히 말하고 싶은 한 타입은 dictionaries입니다. 
리스트처럼, dictionaries 는 변할수 있습니다. 그것들은 여러 다른 종류들로 이뤄질수 있습니다. 
그러나 리스트와 달리, 그것들은 정렬 되지 않습니다. 

Korean: 
그것들에서 요소들은 순서를 가지지 않습니다.  
그리고 더욱이, 우리는 인덱싱을 일반화 했습니다.
그래서 리스트와 스트링, 우리는 정말로, 숫자에 의해서, 
인티져에 의한 요소들만 얻을 수 있습니다. 
여기서 우리가 사용하는 것은, dictionary의 모든 요소를 핵심 키쌍 이라고 생각해보세요.
거기서 핵심은 인덱스들처럼 사용됩니다. 

English: 
The elements in them don't
have an order, and
furthermore, we have generalized
the indexing.
So lists and strings, we can
only get at elements by
numbers, by integers, really.
Here what we use is, think
of every element of the
dictionary as a key value pair,
where the keys are used
as the indices.

English: 
So we can have an example,
let's look at it.
So, if you look at the function
show dics here,
you'll see I've declared a
variable called e to f, ah,
think of that as English to
French, and I've defined a
dictionary to do translations.
And so, we see that the string
one corresponds the-- the key
one corresponds to the value un
the key soccer corresponds
to the French word football,
et cetera.
It's kind of bizarre, but the
French call soccer football.
And then I can index in it.
So if I print e to f of soccer,
it will print the
string football.

Korean: 
그래서 우리는 하나의 예를 가질 수 있습니다. 그것을 살펴 봅시다. 
그래서, 여러분이 여기 dics를 보여주는 함수를 보면, 
여러분은 제가 e to f 라는 변수를 선언했던 것을 볼 수 있습니다, 
아, 그것을 영어에서 프랑스어로와 같다고 생각 하세요. 
그리고 저는 dictionary 를 번역을 하는 것으로 정의 했습니다. 
그래서, 우리는 스트링 하나가 일치 하는 것을 알 수 있습니다.
키는 값과 일치하고, soccer 는 프랑스 단어 football 과 일치 합니다. 
그것은 일종의 특이한 것 입니다. 프랑스어는 soccer 를 football 이라고 부릅니다. 
그리고 나서 저는 그것 안에 인덱스 할 수 있습니다.
그래서 만약 축구의 e to f 를 출력하면,   
그것은 문자열 football 을 출력 할 것 입니다.

Korean: 
그래서 여러분은 이것이 매우 강력한 메커니즘이라는 것을 상상할 수 있습니다. 
제가 돌릴 때 무슨일이 일어나는지 봅시다 – 이것을 돌려 봅시다.
좋아요. 
그래서, 그것은 정의 되지 않았다고 말합니다–그것은 왜 정의 되지 않았다고 말했나요?
흥미로운 질문 입니다.  
우리가 이것을 옳게 가진다고 확실히 해 보고 우리는 다시 보여 주도록 해 봅시다.
좋아요. 그래서, 저는 그것을 돌릴 것 입니다. 충분히 확실히요. 

English: 
So you can imagine that this is
a very powerful mechanism.
So let's look what happens
when I run--
start to run this.
All right.
So, it says not defined-- and
why did it say not defined,
there's an interesting
question.
Let's just make sure we get this
right, and we start the
show up again--
All right, so, I run
it, and sure

Korean: 
그것은 football 을 보여줍니다. 
만약 제가 0 의 e to f 를 하면 무슨 일이 일어나나요?  
저는 키 에러를 갖습니다.
왜냐하면, 기억하세요. 이것들은 정렬 되지 않았습니다. 
0 번째 인자가 없습니다. 
이 특정 객체의 키가 아닙니다. 
이제 저는 키를 만들어야 했습니다. 키는 스트링이 되어서는 안 됩니다.
그러나 그것이 일어났으니, 저는 만들지 않았네요.
그래서 그것을 말해 봅시다. 그래서 우리가 다시 막히지 않게요. 
우리가 전에 있었던 곳에서, 저는 그것을 여기서 출력 했습니다, 

English: 
enough, it shows football.
What happens if I
go e to f of 0?
I get a key error.
Because, remember, these
things are not ordered.
There is no 0th element.
0 is not a key of this
particular object.
Now I could have made 0 a key,
keys don't have to be strings,
but as it happened, I didn't.
So let's comment that out, so
we don't get stuck again.
Where we were before, I've
printed it here, you might be

Korean: 
여러분은 순서에 약간 놀랄 것 입니다. 
왜 soccer 가 첫 번째 인가요? 
왜냐하면 이것의 순서는 중요하지 않기 때문이죠.
그것은 그것이 괄호를 사용하는 이유 입니다. 
그러니 그것에 대해 걱정 하지 마세요. 
제가 하려고 하는 다음 것은 – 그래서 그것은 그것 입니다, 그리고 나서 – 
저는 이제 또 다른 하나를 만들려고 합니다 n to s, 숫자에서 스트링입니다.
거기서 제 키는 숫자 입니다. 
이 경우에 숫자 1 은 단어 one 과 일치 합니다.
그리고 충분히 흥미롭게도, 저는 또한  
숫자 1 과 일치하는 단어 1 을 가질 것 입니다.
저는 제가 값으로 사용 하고 싶은 
어떤 것도 사용 할 수 있습니다. 그리고 이제 우리가 이것을 보면,
우리는 알 수 있죠. 저는 이것을 얻을 수 있습니다. 
좋아요. 
그래서 이것들은 정말로 귀중한 것 입니다. 
저는 이것들로 많은 것을 합니다.

English: 
a little surprised
of the order.
Why is soccer first?
Because the order of this
doesn't matter.
That's why it's using
set braces, so
don't worry about that.
The next thing I'm doing is--
so that's that, and then--
I'm now going to create another
one, n to s, for
numbers to strings, where my
keys are numbers, in this case
the number 1 corresponds
to the word one, and
interestingly enough, I'm also
going to have the word one
corresponding to the number 1.
I can use anything I want for
keys, I can use anything I
want for values.
And now if we look at this,
we see, I can get this.
All right.
So these are extremely
valuable.
I can do lots of things with
these, and you'll see that as

Korean: 
그리고 여러분은 우리가 미래의 대입을 할 때, 우리가 dictionaries를 많이 사용하게
될 것이라는 것을 알게 될 것입니다. 
네. 
질문 하세요. 
교수 : 여러분은 할 수 있습니다. 그러나 여러분은 
그것이 어떤 순서를 갖는지 모릅니다. 
여러분이 할 수 있는 것은 키들을 반복하는 것입니다. 그것은 여러분에게 dictionaries에서 
키들을 줍니다. 그리고 나서 여러분은 그것들을 선택 할 수 있습니다.
그러나 여러분들이 키를 얻는 순서에 대해서는 어떤 보장도 없습니다.
이제 여러분은 궁금할 지도 모릅니다, 왜 우리가 dictionaries를 갖나요? 
그것은 리스트로 그것들을 실행하기 매우 쉽습니다. 왜냐하면 여러분은 리스트의
각 요소가 키 값 쌍인 곳에서 리스트를 가질 수 있었습니다.
그리고 만약 제가 키와 일치하는 값을 찾길 원했다면, 
저는 리스트에서 e를 위해 말할 수 있습니다.
만약 e의 첫 번째 인자가 키면, 그러면 저는 값을 가집니다. 
그렇지 않으면 저는 리스트에서 다음 요소를 봅니다. 
그래서 dictionaries 를 더하는 것, 그림슨 교수가 매우 많은 다른 것들을
가지고 말한 것처럼, dictionaries 를 더하는 것은 여러분에게 

English: 
we get to future assignments,
we'll make heavy use of
dictionaries.
Yeah.
Question.
STUDENT: [INAUDIBLE]
PROFESSOR JOHN GUTTAG: You can,
but you don't know what
order you'll get them in.
What you can do is you can
iterate keys, which gives you
the keys in the dictionary, and
then you can choose them,
but there's no guarantee
in the order in
which you get keys.
Now you might wonder, why
do we have dictionaries?
It would be pretty easy to
implement them with lists,
because you could have a list
where each element of the list
was a key value pair, and if
I wanted to find the value
corresponding to a key, I could
say for e in the list,
if the first element of e is the
key, then I get the value,
otherwise I look at the next
element in the list.
So adding dictionaries, as
Professor Grimson said with so
many other things, doesn't
give you any more

Korean: 
어떤 컴퓨터적인 힘을 더 주진 않습니다.
그것은 여러분에게 많은 표현적인 확신을 줍니다.
여러분은 프로그램을 더욱 잘 깨끗하게 쓸 수 있습니다.
그러나 가장 중요한 것은, 그것은 빠릅니다. 
왜냐하면 만약 여러분이 제가 리스트로 제안했던 것을 했다면, 
키를 찾는 시간은 리스트의 길이에서 
선형 입니다. 
여러분은 여러분이 키를 찾을 때까지 
각 요소들을 모두 보아야 합니다. 
dictionaries 는 해싱이라는 마법의 기술을 사용해서 실행됩니다.
우리는 그것을 이번학기 약간 나중에 볼 것입니다. 
그것은 우리가 일정시간에서 키를 검색하도록 허용합니다.
그래서 dictionary가 얼마나 큰 지는 중요하지 않습니다. 
여러분은 순간적으로 키와 연관된 값을 검색할 수 있습니다. 
매우 강력 합니다.
다음 문제 세트에 있지 않고 그것 다음의 문제 세트에 있습니다. 
우리는 dictionaries 의 기능을 이용할 것 입니다. 
좋아요. 
이것에 대해 어떤 질문 있나요? 

English: 
computational power.
It gives you a lot of expressive
convenience, you
can write the programs much
more cleanly, but most
importantly, it's fast.
Because if you did what I
suggested with the list, the
time to look up the key would be
linear in the length of the
list. You'd have to look
at each element until
you found the key.
Dictionaries are implemented
using a magic technique called
hashing, which we'll look at a
little bit later in the term,
which allows us to retrieve
keys in constant time.
So it doesn't matter how big
the dictionary is, you can
instantaneously retrieve the
value associated with the key.
Extremely powerful.
Not in the next problems set but
in the problem set after
that, we'll be exploiting that
facility of dictionaries.
All right.
Any questions about this?

English: 
If not, I will turn the podium
over to Professor Grimson.
PROFESSOR ERIC GRIMSON:
I've stolen it.
This is like tag team
wrestling, right?
Professor Guttag has you
on the ropes, I get
to finish you off.
Try this again.
OK.
We wanted to finish up that
section, we're now going to
start on a new section, and I
want to try and do one and a
half things in the
remaining time.
I'm going to introduce one topic
that we're going to deal
with fairly quickly, and then
we tackle the second topic,
it's going to start today, and
we're going to carry on.
So let me tell the two
things I want to do.
I want to talk a little bit
about how you use the things
we've been building in terms
of functions to help you

Korean: 
없으면 저는 강단을 그림슨 교수에게 넘기겠습니다. 
에릭 그림슨 교수 : 제가 훔쳤습니다. 
이것은 태그 레슬링 같죠, 네? 
구탁 교수는 여러분을 로프에 두었고 제가 여러분을 이겨서 마무리 할 것입니다. 
이것을 다시 해 봅시다. 
좋습니다.
우리는 그 부분을 끝내려고 합니다. 우리는 이제 새로운 
부분에서 시작할 것 입니다. 그리고 저는 남은시간에 
1.5배를 하려고 노력할 것 입니다. 
저는 우리가 다룰 하나의 주제를 꽤 빠르게 소개할 것 입니다. 
그리고 나서 우리는 두 번째 주제와 씨름을 벌일 것 입니다. 
그것은 오늘 시작할 것 이고, 계속 할 것 입니다. 
그래서 제가 하려고 하는 두 가지 것을 말하겠습니다.
저는 여러분이 여러분의 코드의 구조를 만들고 

Korean: 
코드를 조직하는데 도움을 주기 위해 우리가 함수의 관점에서 
만들었던 것을  
여러분이 어떻게 사용하는지에 대해 약간 이야기할 것 입니다.
그리고 나서 우리는 효율성의 질문으로 돌아 올 것 입니다.
우리가 알고리즘의 효율성을 어떻게 측정 할 수 있나요? 
그것은 우리가 다루고 싶어 하는 정말 중요한것이고,
그것을 오늘 시작할 것 입니다. 그것은 의심할 여지없이
우리가 그것을 끝내기 위해 몇 강의를 더 나가도록 합니다. 
네, 그래서 어떻게 여러분은 코드를 조직하기 위해 
함수의 생각을 사용합니까? 
우리는 그것을 암시적으로 해왔습니다. 
함수를 소개 한 이후로 줄곧 그랬습니다. 
저는 그것을 약간 더 분명하게 하려고 합니다. 
그리고 그것을 하기 위한 도구를 소개하고 싶습니다. 
저그리고 저는 그것을 하는 쉬운 방법이 – 
그것을 예로 하는 것 입니다. 
그래서 정말 간단한 예를 해 보겠습니다. 
저는 직각 삼각형의 빗변의 길이를 계산하려고 합니다.
네, 저는 여러분이 그것을 어떻게 
하는지 알고 있다는 것을 압니다, 그러나 제가 그것을 하길
원한다면 무슨 일이 일어날지에 대해 생각해 봅시다. 
그리고 특히, 만약 제가 그 문제에 대해 생각 한다면 
– 사실 저는 이것을 하고 싶습니다 – 만약 제가 그 문제에 대해 생각 한다면,
저는 약간의 의사 코드를 쓸 것 입니다. 

English: 
structure and organize
your code.
It's a valuable tool that you
want to have as a programmer.
And then we're going to turn to
the question of efficiency.
How do we measure efficiency
of algorithms?
Which is going to be a really
important thing that we want
to deal with, and we'll start
it today, it's undoubtedly
going to take us a couple more
lectures to finish it off.
Right, so how do you
use the idea of
functions to organize code?
We've been doing it implicitly,
ever since we
introduced functions.
I want to make it a little more
explicit, and I want to
show you a tool for
doing that.
And I think the easy way
to do is-- is to
do it with an example.
So let's take a really
simple example.
I want to compute the
length of the
hypotenuse of a right triangle.
And yeah, I know you know how
to do it, but let's think
about what might happen if
I wanted to do that.
And in particular, if I think
about that problem-- actually
I want to do this-- if I think
about that problem, I'm going
to write a little piece
of pseudo code.

Korean: 
제가 그 문제를 어떻게 해결 하는지에 대해 생각 해 보기 위해서요. 
의사 코드 (슈도 코드)입니다. 
이제, 여러분은 모든 언어의 전공을 갖습니다. 슈도는 false 를 의미합니다.
이것은 코드가 동작하지 않을 것이라는 것처럼 들립니다.
그리고 그것은 용어의 의도가 아닙니다. 
제가 의사 코드를 말할 때, 제가 의미하는 것은, 
저는 단계의 설명을 쓰려고 하는 것 입니다. 
특정 프로그래밍 언어로 쓰려는 것이 아니라요. 
저는 단순히 제가 하려고 하는 것의 
설명을 쓸 것 입니다. 
그래서 만약 제가 이 문제를 풀려고 한다면, 
여기에 제가 그것을 하는 방법이 있습니다. 
저는 이렇게 말할 겁니다. 제가 하고 싶은 첫 번째 것은, 
제가 실수로써 기본적인 것인 값을 입력하고 싶은 것입니다. 
기본적인 것을 집어 넣을 필요가 있습니다. 
제가 하고 싶은 두 번째 것은, 저는 높이를 구할 필요가 있습니다. 
그래서 저는 높이를 위한 값을 입력할 것 입니다. 
역시 실수로요, 실수형으로 합니다. 
네. 
저는 두 값을 입력 했습니다. 제가 해야 하는 것은 무엇인가요. 
자, 여러분은 그것을 알고 있나요, 네? 

English: 
Just to think about how I would
break that problem up.
Pseudo code.
Now, you're all linguistic
majors, pseudo means false,
this sounds like code that ain't
going to run, and that's
not the intent of the term.
When I say pseudo code, what I
mean is, I'm going to write a
description of the steps,
but not in a particular
programming language.
I'm going to simply write
a description of what
do I want to do.
So if I were to solve this
problem, here's the way I
would do it.
I would say, first thing I want
to do, is I want to input
a value for the base
as a float.
Need to get the base in.
Second thing I want to do, I
need to get the height, so I'm
going to input a value for the
height, also as a float, a
floating point.
OK.
I get the two values in, what
do I need to do, well, you
sort of know that, right?

English: 
I want to then do, I need to
find the square root-- b
squared plus h squared, right?
The base plus the height, that's
the thing I want for
the hypotenuse-- and I'm going
to save that as a float in
hyp, for hypotenuse.
And then finally I need to print
something out, using the
value in hyp.
OK.
Whoop-dee-doo, right?
Come on.
We know how to do this.
But notice what I did.
First of all, I've used the
notion of modularity.
I've listed a sequence of
modules, the things that I
want to do.
Second thing to notice, is that
little piece of pseudo
code is telling me things
about values.
I need to have a float.
I need to have another float
here, it's giving me some
information.

Korean: 
저는 그리고 그것을 하고 싶고, 제곱근을 찾아야 합니다. 
– b제곱 더하기 h제곱, 맞나요? 
높이에 기본값을 더합니다, 그것은 제가 빗변을 구하기 위한것 입니다 – 
그리고 저는 그것을 hyp, 
빗변에 실수로 저장할 것 입니다. 
그리고 나서 마지막으로 저는 그것을 출력 해야 합니다. 
hyp 에 있는 값을 이용해서요. 
네. 
이런, 네? 
자 해 봅시다. 
우리는 이것을 하는 방법을 알고 있습니다. 
그러나 제가 했던 것에 집중해 보세요.
무엇보다도, 저는 모듈 방식의 개념을 사용 했습니다. 
저는 모듈의 순서를 리스트 했습니다.
그것은 제가 하고자 한 것입니다. 
주목 해야 할 두 번째 것은, 약간의 의사 코드가   
저에게 값에 대한 것을 말해줍니다. 
저는 실수를 가져야 합니다. 저는 여기서 
또 다른 실수를 가지는데, 그것은 저에게 
어떤 정보를 줍니다.

English: 
Third thing to notice is,
there's a flow of control.
The order which these things
are going to happen.
And the fourth thing to notice
is, I've used abstraction.
I've said nothing about how I'm
going to make square root.
I'm using it as an abstraction,
saying I'm going
to have square root from
somewhere, maybe I'll build it
myself, maybe somebody gives it
to me as part of a library,
so I'm burying the details
inside of it.
I know this is a simple example,
but when you mature
as a programmer, one of the
first things you should do
when you sit down to tackle
some problem is write
something like this
pseudo code.
I know Professor Guttag
does it all the time.
I know, for a lot of
you, it's like, OK,
I got a heavy problem.
Let's see, def Foobar open
paren, a bunch of parameters.
Wrong way to start.
Start by thinking about what
are the sequences.
This also, by the way, in some
sense, gives me the beginnings
of my comments for what
the structure of my
code is going to be.
OK.
If we do that, if you look at
the handout then, I can now
start implementing this.
I wanted to show you that, so,
first thing I'm going to do is
say, all right, I know I'm going
to need square root in

Korean: 
주목 해야 할 세 번째 것은, 제어의 흐름이 있습니다. 
이것들이 일어나려고 하는 순서죠.
그리고 주목해야 할 네 번째 것은, 저는 추상화를 사용했습니다. 
저는 제가 제곱근을 만들 방법에 대해 아무 것도 이야기하지 않았습니다. 
저는 그것을 추상화로써 사용했고, 어디로부터 제곱근을 사용할 것이라고 말했습니다.
아마 저는 그것을 제 스스로 만들 것 입니다.
아마 누군가가 그것을 제게 라이브러리의 일부로써 줄 것 입니다. 
그래서 저는 그것의 내부에 자세한 사항들을 묻어둘 것 입니다.
저는 이것이 간단한 예 라는 것을 압니다.
그러나 여러분이 프로그래머로써 성숙할 때, 여러분이 어떤 문제와 씨름 하려고  
앉았을 때 여러분이 해야 하는 첫 번째 것 중의 하나는
이 의사 코드 같은 것을 쓰는 것 입니다. 
저는 구탁 교수도 그것을 항상 한다는 것을 알고 있습니다. 
저는 알고 있습니다, 여러분 중 많은 사람들이, 그와 같다는걸요.
네, 저는 많은 문제를 가지고 있습니다. 
자 봅시다, def Foobar 열린 괄호, 많은 인자들이 있습니다. 
시작하는 잘 못 된 방법 입니다. 
 
332
00:23:40,210 --> 00:23:41,970
순서가 무엇인지에 대해 생각하는 것으로써 시작해야 합니다.
이것은 또한, 그런데, 어떤 의미에서, 
저에게 제 코드의 구조가 무엇일 것인지에 대하여 
제 코멘트의 시작을 줍니다. 
좋아요.
우리가 그것을 한다면, 여러분이 그리고 나서 핸드 아웃을 본다면, 
저는 이제 이것을 실행 하는 것을 시작할 수 있습니다. 
저는 여러분에게 그것을 보여 주고 싶었습니다.
그래서, 제가 하려고 하는 첫 번째 것은 말하는 것 입니다. 좋아요. 

English: 
here, so I'm going to,
in fact, import math.
That's a little different from
other import statements.
This says I'm going to get the
entire math library and bring
it in so I can use it.
And then, what's the first
thing I wanted to do?
I need to get a value
for base as a float.
Well OK, and that sounds like
I'm going to need to do input
of something, you can see that
statement there, it's-- got
the wrong glasses on
but right there--
I'm going to do an input with
a little message, and I'm
going to store it in base.
But here's where I'm going to
practice a little bit of
defensive programming.
I can't rely on Professor Guttag
if I give this-- if
this code to him, I can't rely
on him to type in a float.
Actually I can, because he's a
smart guy, but in general, I
can't rely on the user--
PROFESSOR JOHN GUTTAG: I
wouldn't do it right
to see if you did.
PROFESSOR ERIC GRIMSON:
Actually,
he's right, you know.
He would not do it, just to
see if I'm doing it right.
I can't rely on the user.
I want to make sure I
get a float in it,
so how do I do that?
Well, here's one nice
little trick.
First of all, having read in
that value, I can check to
see, is it of the right type?
Now, this is not the nicest way
to do it but it'll work.

Korean: 
저는 제가 여기서 제곱근이 필요 하다는 것을 압니다. 그래서, import math 를 할 것 입니다. 
그것은 다른 import 문장들과는 약간 다릅니다. 
이것은 제가 전체의 수학 라이브러리를 가지고 그것을 가져와서 
제가 그것을 사용할 수 있다고 말합니다.
그리고 나서, 제가 하려고 했던 첫 번째 것은 무엇입니까? 
저는 실수로 기본적인 것의 값을 얻어야 합니다. 
자 네, 그리고 그것은 제가 그것을 입력해야 
한다는것처럼 들리는군요. 여러분은 그 문장을 저기서 볼 수 있습니다.  
그것은 – 안경을 잘 못 꼈는데 아 바로 여기에 있네요.
저는 작은 메시지로 입력을 할 것 입니다.  
그리고 저는 베이스 안에 그것을 저장할 것 입니다.
그러나 여기는 약간의 방어적인 
프로그래밍을 연습할 곳 입니다. 
저는 구탁 교수에 의존할 수 없습니다.  
만약 이 코드를 그에게 주면, 저는 그에게 실수에 타이프 하는 것을 의존 할 수 없습니다. 
사실 저는 할 수 있습니다. 왜냐하면 그는 똑똑한 사람 입니다.
그러나 일반적으로 저는 사용자에 의존할 수 없습니다. 
존 구탁 교수 : 만약 당신이 한다면, 나는 보려고
바로 그 일을 하진 않을 겁니다.
에릭 그림슨 교수 : 사실, 그가 옳습니다, 여러분도 알다시피 
그는 그것을 하지 않을 것입니다. 제가 그것을 옳게 하고 있는지 보기 위해서요. 
저는 사용자에 의존할 수 없습니다. 
저는 제가 그 안에 실수를 얻을 것이라는 것을 확실히 하고 싶습니다. 
그래서 제가 그것을 어떻게 할 수 있죠? 
자, 여기 하나의 좋은 약간의 속임수가 있습니다. 
무엇보다도, 그 값에서 읽으면, 저는 확인 할 수 있습니다.
그것이 오른쪽 타입에 있나요? 
이제 이것은 그것을 하는 가장 좋은 방법이 아니지만, 그것은 작동 할 것 입니다. 

Korean: 
저는 base 의 값의 타입을 볼 수 있습니다. 그리고 그것을 실제의 실수의 타입과 
비교하고 볼 수 있습니다. 그것들은 같은가요? 
이것은 진짜 인가요 또는 실수 인가요?  
만약 그렇다면, 다 된겁니다.
제가 그것이 아니면 어떻게 되돌아 오나요? 
자, 저는 작은 무한 루프를 만들 것 입니다. 
일반적으로 좋은 생각은 아닙니다. 
저는 여기서 변수를 만들 것입니다. 그 변수는 input입니다. 네. 
초기에 그것은 false 입니다. 왜냐하면 제가 아무 입력도 하지 않았기 때문 입니다. 
그리고 나서 저는 제가 그것을 읽는 곳에서 루프를 돌립니다.
저는 그것이 옳은 타입인지 보려고 검사 할 것 입니다. 만약 옳으면, 
저는 그 변수를 그것이 이제 옳은 타입이라고 말하는 것으로 바꿀 것입니다.
그것은 루프를 통해 다음을 의미 합니다. 저는 제가 모두 만들었고 
저는 내뱉어야 한다고 말할 것 입니다. 
그러나 그것이 옳지 않으면, 여기서 여러분은 망쳤습니다 라고 
말하는 메시지를 출력할 것 입니다. 다소 정중하게요. 
그리고 그것은 다시 주변으로 돌아 갈 것 입니다. 
그래서 그것은 제가 옳은 타입의 것을 얻을 때까지 순환일 것 입니다. 
그것을 하는 좋은 방법입니다.  
좋아요, 제가 하는 두 번째 것은 무엇입니까? 
자, 저는 높이에서 읽힐 같은 종류의 것들을 얻습니다.
제가 한 번 그것을 가지면 저는 제곱 된 base 더하기 제곱 된 높이를 가질 것입니다.
그리고 우리가 방금 전에 본 형태가 있습니다. 그리고 그것은 그것을 

English: 
I can look at the type of the
value of base and compare it
to the type of an actual float
and see, are they the same?
Is this a real or a float?
If it is, I'm done.
How do I go back if it isn't?
Well, I'm going to create
a little infinite loop.
Not normally a good idea.
I set up a variable here,
called input OK.
Initially it's false, because
I have no input.
And then I run a loop in which
I read something in, I check
to see if it's the right type,
if it is, I change that
variable to say it's now the
correct type, which means the
next time through the loop, I'm
going to say I'm all set
and I'm going to bounce out.
But if it is not, it's going
to print out a message here
saying, you screwed up, somewhat
politely, and it's
going to go back around.
So it'll just cycle until
I get something
of the right type.
Nice way of doing it.
Right, what's the second
thing I do?
Well, I get the same sort of
thing to read in the height,
once I have that I'm going to
take base squared plus height
squared, and there's a form
that we've just seen once

English: 
before, and it's going to repeat
it, that is math.SQRT
and it says the following: it
says, take from the math
library the function
called sqrt.
OK.
We're going to come back to this
when we get to objects,
it's basically picking up that
object and it's applying that,
putting that value into hype,
and then just printing
something out.
And again, if I just run this,
just to show that it's going
to do the right thing, it says
enter base, I'm obnoxious, it
says oops, wasn't a float, so
we'll be nice about it, and I
enter a height, and it prints
out what I expected.
I just concatenated those
strings together, by the way,
at the end.
All right.
Notice what I did.
OK.
I went from this description,
it gives me [UNINTELLIGIBLE]
some information.
I need to have a particular
type.
I made sure I had the
particular type.
I've used some abstraction to
suppress some details here.
Now if you look at that list,
there is actually something I

Korean: 
반복할 것 입니다. 그것은 math.SQRT 입니다.
그리고 그것을 다음을 말할 것 입니다 : 그것은 말합니다. 
수학 라이브러리에서 squr 라는 함수를 가져오세요. 
좋습니다.
우리는 우리가 객체를 다룰 때 이것으로 다시 돌아올 것입니다. 
그것은 기본적으로 그 객체를 가져올 것 입니다. 
그리고 그것은 그것에 적용할 것이고 hype에 그 값을 둡니다. 
그리고 나서 무엇을 프린트 합니다. 
다시 이것을 돌리면, 그것이 옳은 것을 할 것이라는 것을 보여 주기 위해, 
그것은 enter base 를 말합니다. 몹시 기분이 나쁘네요.
아이구, 실수형이 아니군.이라고 말하네요. 그래서 우린 그것에 대해 좋을것 입니다, 
그리고 높이를 입력합니다. 그리고 그것을 제가 예상했던 것을 출력 합니다.
저는 문자열들을 함께 연결 시킵니다. 
그런데, 마지막에요. 
좋아요.
제가 한 것을 주목 하세요. 
네. 
저는 이 설명으로부터 왔습니다. 그것을 저에게 줍니다.
 어떤 정보들을요. 
저는 특정한 타입을 가져야 합니다. 
저는 제가 특정한 타입을 가지는 것을 확실히 했습니다. 
저는 여기서 어떤 자세한 것을 숨기기 위해 어떤 추상화를 사용했습니다.  
이제 만약 여러분이 그 리스트를 보면, 사실 제가 검사하지 않은 

Korean: 
것으로 보이는 것이 있습니다. 그것은 제가 hyp 에서 저장된 
제가 실수를 원했다고 말하는것 입니다. 
제가 어떻게 제가 hyp에서 실수를 갖는 것을 아나요? 
자 저는 계약에 의존할 것 입니다. 
여러분이 원한다면, 제곱근의 제조자를 함께 둡니다.
즉, 제가 그것에게 두 실수를 준다는 것을 알면, 제가 일을 하는,
왜냐하면 저는 그것들이 실수라는 계약을 확실히 하기 때문 입니다. 
여러분이 원한다면, 그 제곱근의 계약은 제가 여러분에게 실수를 돌려줄 것이라고 말합니다.
그래서 저는 제가 옳은 타입의 것을 가진다고 보장할 수 있습니다. 
네.
저는 이것이 어떤 것과 같을 만큼 지루하다는 것을 압니다. 
그러나 여기 중요한 포인트가 있습니다. 
이제 이 의사 코드를 그것들을 정렬하기 위해 사용하여, 
저는 어떤 추가적인 구조를 이것에 두는 것을 시작 할 수 있습니다. 
그리고 특히, 저는 여러분이 이것을 볼 것이라고 확신 합니다 
 
430
00:27:37,029 --> 00:27:39,170
– 여러분은 그것을 볼 것 입니다 만약 우리가 옳은 것을 본다면요 –
이것은, 잠깐만요.
이 코드 덩어리와 이 코드 덩어리는, 그것들은 
정말로 같은 것을 합니다. 
그리고 이것은 제가 사용하길 원하는 것 입니다. 
만약 제가 계산의 이 두 가지 것을 보면,  
저는 거기서 패턴을 볼 수 있습니다.
그것은 제가 하고 있는 것의 명백한 패턴 입니다. 
그리고 특히, 저는 그리고 다음 질문을 할 수 있습니다, 

English: 
didn't seem to check, which is,
I said I wanted a float
stored in hyp.
How do I know I've got
a float in hyp?
Well I'm relying on the
contract, if you like, that
the manufacturer of square root
put together, which is,
if I know I'm giving it two
floats, which I do because I
make sure they're floats, the
contract, if you like, of
square root says I'll give
you back a float.
So I can guarantee I've got
something of the right type.
OK.
I know this is boring
as whatever.
But there's an important
point here.
Having now used this pseudo code
to line things up, I can
start putting some additional
structure on this.
And in particular, I'm sure
you're looking at this going--
will look at it if we look
at the right piece--
going, wait a minute.
This chunk of code and this
chunk of code, they're really
doing the same thing.
And this is something
I want to use.
If I look at those two pieces
of computation, I can see a
pattern there.
It's an obvious pattern
of what I'm doing.
And in particular, I can then
ask the following question,

Korean: 
그것은, 이 두 코드 간에 다른 점이  
무엇 입니까?
그리고 저는 두 가지를 제안 합니다, 맞나요? 
하나는, 제가 입력을 요청 할 때 제가 출력한 것은 
무엇 입니까? 
두 번째 것은, 제가 만약 실제로 옳은 입력을 넣지 않으면  
저는 무엇을 출력 합니까?
그리고 그래서 오직 두 차이점은, 바로 저기 있습니다, 
그리고 여기와 여기 사이에 있습니다. 
그래서 이것은 생각 해 볼 좋은 곳 입니다. 네. 
그것을 포착해 보겠습니다. 
제가 함수를 쓸 것 입니다. 사실 제가 하는 문자 
그대로의 것은, 변하는것을 식별하는 것입니다. 
그들 각각에게 변수 이름을 줍니다. 왜냐하면 저는 그것들을 언급하고 싶기  
때문입니다. 그리고나서 이 변수 이름을 내부에
가진 계산의 나머지를 포착하는 함수를 씁니다. 
그리고 사실, 만약 여러분이 아래를 보면 – 그리고 저는 이 부분을 강조 할 것입니다.
저는 그것을 돌리지 않을 것이지만,
만약 여러분이 여기 아래를 보면, 그것은 정확히 그것이 하는 것입니다. 
저는 그것을 코멘트 했습니다. 맞나요? 
그것이 무엇을 합니까? 
그것은 높이를 갖고, 제가 그것들의 두 이름을 가지고 있다고 말합니다: 
요청 메시지와 에러 메시지 입니다. 
그 함수의 본체는 정확하게 위의 계산과 같아 보입니다.

English: 
which is, what's different
between those
two pieces of code?
And I suggest two
things, right?
One is, what's the thing
I print out when
I ask for the input?
The second thing is, what do I
print out if I actually don't
get the right input in?
And so the only two differences
are, right there,
and there versus
here and here.
So this is a good place to
think about, OK, let me
capture that.
Let me write a function, in fact
the literal thing I would
do is to say, identify the
things that change, give each
of them a variable name because
I want to refer to
them, and then write a function
that captures the
rest of that computation
just with those
variable names inside.
And in fact, if you look down--
and I'm just going to
highlight this portion, I'm not
going to run it-- but if
you look down here, that's
exactly what that does.
I happen to have it commented
out, right?
What does it do?
It has height, it says, I've got
two names of things: the
request message and
the error message.
The body of that function
looks exactly like the

Korean: 
제가 전에 가지고 있던 구체적인 메시지의 장소에서 그것들을 
단순히 사용하는 것을 제외 하고요. 
그리고 나서 유일한 다른 차이점은 명백히
그것이 제가 값을 리턴 해야하는 함수 라는 것 입니다. 
그래서 제가 다 했을 때, 저는 값을 돌려줘야 합니다. 
맞죠? 
그리고나서 제가 기본적으로, 이 코드를 해 보겠습니다. 그것을 다하고, 
저는 간단히 실수를 갖는 base와 실수를 갖는 높이를 호출 합니다.
그리고 남은 일을 합니다. 
좋아요. 
이것을 하는 것의 포인트는 무엇입니까? 
자, 다시 주목 하세요. 
제가 한 것은 무엇입니까? 
저는 함수 내부에서 모듈을 포착했습니다. 
그리고 심지어 그것이 여기 간단한 작은 것이라해도, 
이것에 몇 가지 정말 좋은 이점들이 있습니다. 
알겠죠? 
첫 번째 것은 읽을 코드가 적다는 것 입니다. 
그것은 디버깅하기 쉽습니다. 
제가 다를 것이 그리 많지 않습니다. 
그러나 더 중요한 것은, 저는 이제 기능으로부터  
실행 또는 사용으로부터 실행을
분리했다는 것입니다.
그것이 의미하는 것은 무엇입니까? 
그것은 그 작은 실수를 얻는 함수를 사용하는 누구라도 그것의 내부에 무엇이 있는지 
걱정할 필요가 없다는 것입니다.
그래서 예를 들어, 저는 제가 출력한 

English: 
computation up above, except
I'm simply using those in
place of the specific message
I had before.
And then the only other
difference is obviously, it's
a function I need to
return a value.
So when I'm done, I'm going to
give the value back out.
All right?
And that then let's me get
to, basically, this code.
Having done that, I simply call
base with get float, I
call height with get float, and
do the rest of the work.
All right.
What's the point
of doing this?
Well, notice again.
What have I done?
I've captured a module
inside of a function.
And even though it's a simple
little thing here, there's
some a couple of really nice
advantages to this.
All right?
First one is there's
less code to read.
It's easier to debug.
I don't have as much
to deal with.
But the more important thing
is, I've now separated out
implementation from
functionality, or
implementation from use.
What does that mean?
It means anybody using that
little function get float
doesn't have to worry about
what's inside of it.
So for example, I decide I want
to change the message I

Korean: 
메시지를 바꾸길 원한다고 결정합니다. 저는 함수를 바꿀 필요가 없습니다.
저는 단지 다른 인자를 전해 줍니다. 
자 만약 제가 – 여러분이 알다 시피, [안 들림] 와 함께, 
미안해요. 제가 그것을 다르게 말해 보겠습니다.
저는 검사가 어떻게 되었는지에 대해 걱정할 필요가 없습니다.
그것은 그 함수의 내부에서 다루어 집니다. 
만약 제가 입력을 얻는 더 좋은 방법이 있다고 결정 하면, 
그러면 저는 입력을 사용하는
코드를 바꿀 수 있습니다. 
그래서, 여러분이 원한다면, 저는 사용자와 
실행자 사이의 분리를 구축 합니다. 그리고 그것은 정확히
제가 함수를 가지고 싶은 이유들 중 하나 입니다, 
왜냐하면 저는 그것들을 분리했기 때문이죠.
또 다른 방법은, 실수를 얻는 것을 사용하는 어떤 것 내부에 자세한 것들이 무엇이 
있는지 또는 무엇이 있으면 안 되는지 신경쓰지 않는다는 것입니다.
그리고 만약 제가 그 정의를 바꾸면, 저는 제 코드에 어디에 
있는 어떤 것도 바꾸면 안됩니다. 반면에 만약 제가 거기서 
그대로의 코드를 가진다면, 저는 가서 그것을 해야 합니다. 
좋아요, 그래서 우리가 여러분이 이것으로부터 가져 오길 바라는 것은, 
여러분이 문제를 시작하기 위해 앉았을 때 의사 코드를 사용하는 
습관을 갖고 단계들이 무엇인지 적으세요. 

English: 
print out, I don't have to
change the function, I just
pass in a different parameter.
Well if I-- you know, with
[UNINTELLIGIBLE PHRASE sorry,
let me say it differently.
I don't need to worry about
how checking is done, it's
handled inside of
that function.
If I decide there's a better
way to get input, and there
is, then I can make it to change
what I don't have to
change the code that
uses the input.
So, if you like, I've built a
separation between the user
and the implementer.
And that's exactly one of the
reasons why I want to have the
functions, because I've
separated those out.
Another way of saying it is,
anything that uses get float
doesn't care what the details
are inside or shouldn't, and
if I change that definition, I
don't have to change anything
elsewhere in my code, whereas if
I just have the raw code in
there, I have to go
off and do it.
Right, so the things we want
you to take away from this
are, get into the habit of using
pseudo code when you sit
down to start a problem, write
out what are the steps.

Korean: 
저는 여러분에게 좋은 프로그래머는, 적어도 제 생각에, 사실  
그들이 무엇을 빠트렸다는 것을 깨달을 때 의사 코드로 
돌아 가서 그것을 수정해야 합니다. 그러나 그것은 여러분이 코드의 더미 
중간에 있을 때 보다 여러분이 간단한 단계의 세트를 볼 때 
그것을 하는 것이 더 쉽습니다.
그리고 무엇이 제어의 흐름인지 여러분이 정의하는 것을 돕기 위해 
그것을 사용하는 습관을 가지세요. 
기본적인 모듈들이 무엇인지, 코드가 작동하도록 하기 위해  
이 모듈들 사이에 어떤 정보가 전해져야 하는지를요.
네.
그것은 짧은 주제였습니다. 
저는 이것으로 약간 더 돌아올 것입니다 
그리고 여러분은 이것으로 많은 연습을 할 것 입니다. 
제가 하고 싶은 것은 다른 주제에 대해 이야기를 
시작하는 것 입니다. 
그것은 효율성 입니다. 
그리고 이것은 이상한 주제처럼 들릴 것 입니다. 
우리는 곧 그것에 왜 값에 있는지 볼 것 입니다. 
저는 효율성에 대하여 이야기 하고 싶습니다. 그리고 우리는 
할 것 입니다. 적어도 저는 할 것 입니다.
가끔은 이것을 증가의 순서로 언급하기도 할 것입니다.
여러분이 다음 몇 분 동안 볼 것을 위해서요. 
이제, 효율성은 명백하게 중요한 고려사항입니다. 여러분이 코드를 설계 할 때요. 

English: 
I will tell you that a good
programmer, at least in my
mind, may actually go back and
modify the pseudo code as they
realize they're missing things,
but it's easier to do
that when you're looking at a
simple set of steps, than when
you're in the middle
of a pile of code.
And get into the habit of using
it to help you define
what is the flow of control.
What are the basic modules, what
information needs to be
passed between those
modules in order to
make the code work.
OK.
That was the short topic.
I will come back to this some
more and you're going to get
lots of practice with this.
What I want to do is
to start talking
about a different topic.
Which is efficiency.
And this is going to sound
like a weird topic, we're
going to see why it's of
value in a second.
I want to talk about efficiency,
and we're going
to, or at least I'm going to, at
times also refer to this as
orders of growth, for reasons
that you'll see over the next
few minutes.
Now, efficiency is obviously
an important consideration

Korean: 
비록 제가 허용해야 할지라도요. 적어도 저에게, 
저는 보통 적어도 작동하는 코드로 초기에 시작하길 원합니다. 
그리고 나서 제가 돌아 가서 더 효율적인 실행을 
생산하는 방법에 대해 걱정합니다. 
저는 제가 의존할 수 있는 것을 가지고 싶은데 
그것은 중요한 이슈입니다. 
그리고 다음 몇 강의에서 우리의 목표는, 
기본적으로 여러분에게 이것의 감각을 주는 것 입니다. 
그래서 우리는 여러분을 컴퓨터의 
효율성 전문가로 바꾸지 않을 것입니다. 
즉, 그것에 대한 전체적인 코스들이 있습니다. 그것에 대한 
여기 몇 가지 훌륭한 강의들도 있고요, 그것은 어떤 
수학적인 교양을 가집니다. 우리는 그것을 약간 밀어낼 것입니다. 
그러나 우리가 하고 싶은 것은, 여러분에게 우리가 어떻게 
효율성의 질문에 접근하는지에 대한 어떤 직관을 주는 것 입니다. 
우리는 여러분이 왜 어떤 프로그램이 여러분이 그것을 타이프를 다 하기 전에 
거의 완성 되는지에 대한 감각을 가지길 원합니다. 
어떤 프로그램은 밤새 돌아 갑니다. 
어떤 프로그램은 제가 늙어서 머리가 
셀 때까지 멈추지 않습니다.
그리고 이것들은 정말 다른 효율성 입니다.
그리고 우리는 여러분에게 여러분이 이 다른 프로그램들에 대한 
이성을 어떻게 가지는지에 대한 감각을 줄 것 입니다. 
그리고 그 일부로 여러분이 카탈로그를 갖는 방법을 배우도록할 것입니다.

English: 
when you're designing code,
although I have to admit, at
least for me, I usually want
to at least start initially
with code that works, and then
worry about how I might go
back and come up with more
efficient implementation.
I like to have something I
can rely on, but it is an
important issue.
And our goal over the next
couple of lectures, is
basically to give you
a sense of this.
So we're not going to turn
you into an expert on
computational efficiency.
That's, there are whole courses
on that, there's some
great courses here on that,
it takes some mathematical
sophistication, we're going to
push that off a little bit.
But what we-- what we do want
to do, is to give you some
intuition about how to
approach questions of
efficiency.
We want you to have a sense of
why some programs complete
almost before you're
done typing it.
Some programs run overnight.
Some programs won't stop
until I'm old and gray.
Some programs won't stop until
you're old and gray.
And these are really different
efficiencies, and we want to
give you a sense of how do you
reason about those different
kinds of programs.
And part of it is we want you
to learn how to have a

English: 
catalog, if you like, of
different classes of
algorithms, so that when you get
a problem, you try and map
it into an appropriate class,
and use the leverage, if you
like, of that class
of algorithms. Now.
It's a quick sidebar, I've got
to say, I'm sure talking about
efficiency to folks like you
probably seems really strange.
I mean, you grew up in an age
when computers were blazingly
fast, and have tons of memory,
so why in the world do you
care about efficiency?
Some of us were not so lucky.
So I'll admit, my first computer
I program was a PDP6,
only Professor Guttag even knows
what PDP stands for, it
was made by Digital Equipment
Company, which does not exist
anymore, is now long gone.
It had, I know, this is
old guy stories, but
it had 160k of memory.
Yeah.
160k.
160 kilobits of memory.
I mean, your flash cards have
more than that, right?
It had a processor speed
of one megahertz.

Korean: 
여러분이 원한다면, 알고리즘의 다른 클래스의 카탈로그를 말합니다.
그래서 여러분이 문제를 가질때, 여러분은 그것을 적절한 클래스로 보여주려 시도합니다.
그리고 지렛대를 사용 합니다. 여러분이 원한다면, 
알고리즘의 그 클래스의 것이 될 것입니다.
이제,
그것은 빠른 보조적인 것 입니다. 저는 말할것입니다. 
저는 여러분 같은 사람들에게 효율성에 대해 말하는것이 정말 이상하다고 확신합니다. 
제가 의미 하는 것은, 여러분은 컴퓨터가 아주 빠를때 성장한 세대입니다.
그리고 많은 메모리를 가지고 있습니다. 그런 세계에서 여러분이 
왜 효율성에 대해 걱정 해야 합니까? 
우리들 중 몇몇은 그렇게 운이 좋지 않습니다. 
그래서 저는 허용할 것이고, 제가 프로그램 한 제 첫 번째 컴퓨터는 PDP6 입니다.
오직 구탁 교수만 PDP 가 무엇을 나타내는지 알고 있을 거에요.
그것은 Digital Equipment Company 에 의해 만들어 졌습니다.
그것은 지금은 더 이상 존재하지 않는 회사입니다.
그것은 가졌었고, 이것은 오래된 이야기 입니다.
그러나 그것은 160k 메모리를 가졌습니다.   
네.
160k.
160 킬로 바이트 메모리를요. 
여러분의 플래시 카드는 그것보다 더 많은 메모리를 가지고 있을 것입니다, 그렇죠? 
그것은 1 메가 헤르츠 속도의 처리기를 가지고 있습니다. 

Korean: 
그것은 초 당 백만 번 연산합니다. 
그래서 그것에 대해 생각해 봅시다. 
이것을요, 그것은 저기서 무엇을 가집니까? 
그 에어 맥을요, 그것은, 봅시다. 그것의 – 제 에어 맥은, 저는 존 교수 것은 
잘 모릅니다만 아마 존 교수 것이 더 좋을 거에요,.
제 것은 1.8 기가 헤르츠 스피드를 가집니다. 
그것은 1800 배 더 빠릅니다. 
그러나 저를 죽이는 진짜 한 가지는, 그것이 그 내부에 2 기가의 
메모리를 가진다는 것 입니다. 
그것은 만 2천 배 더 메모리를 가집니다. 
오, 그리고 그런데요? 
PDP6, 그것은 이 큰 선반에 있었습니다.  
바닥으로부터요, 테이블로부터가 아니라요.
좋아요, 그래서 여러분은 저와 같이 1800년대 후반에 
자라지 않았습니다. 여러분은 이런 것들에 대해 걱정할 
필요가 없습니다, 그렇죠? 
그러나 제가 강조하고 싶은 것은, 그것은 더 이상 컴퓨터가 
매우 많이 빠른 것을 가지지 않은 것처럼 들립니다.
왜 여러분은 그것에 대해 걱정해야합니까? 
제가 여러분에게 제가 저항 할 수 없는 하나의 다른 일화를 주겠습니다. 
이것은 여러분이 칵테일 파티에서 하버드 다니는 친구에게 
깊은 인상을 주기 위해 사용할 수 있는 것입니다. 
네.
네. 제가 작은 램프, 작은 거위를 가진다고 상상하세요--이 작은 거위 목  
모양의 램프 중 하나는, 저는 그것을 여기 테이블에 놓았고 
그것에 대한 키를 두었습니다. 테이블 아래 바닥에 대한 것입니다.
그리고 만약 제가 정말 좋았다면, 저는 칠 수 있거나 그것의 시간을 맞출 수 있습니다. 

English: 
It did a million operations
per second.
So let's think about it.
This sucker, what's
it got in there?
That Air Mac, it's, see, it's
got, its go-- my Air Mac, I
don't know about John's, his is
probably better, mine has
1.8 gigahertz speed.
That's 1800 times faster.
But the real one that blows me
away is, it has 2 gig of
memory inside of it.
That's 12 thousand times
more memory.
Oh, and by the way?
The PDP6, it was in a rack
about this tall.
From the floor, not
from the table.
All right, so you didn't grow
up in the late 1800s like I
did, you don't have to
worry about this
sort of stuff, right?
But a point I'm trying to make
is, it sounds like anymore
computers have gotten so
blazingly fast, why should you
worry about it?
Let me give you one other
anecdote that I can't resist.
This is the kind of thing you
can use at cocktail parties to
impress your friends
from Harvard.
OK.
Imagine I have a little lamp, a
little goose-- one of those
little gooseneck lamps, I'd put
it on the table here, I'd
put the height about a f-- about
a foot off the table.
And if I was really good, I
could hit, or time it so that

Korean: 
그래서 제가 다칠 때 – 네, 다시 해 보겠습니다. 
제가 램프에서 이 스위치를 킬 때, 정확하게 동시에, 
 
609
00:35:03,070 --> 00:35:05,430
저는 제 컴퓨터에 있는 키를 칠 것이고  
그것이 돌기 시작 할 것 입니다.
네.
시간의 길이에서 빛은 전구에서 테이블까지 걸립니다. 
이 기계는 두 연산을 처리 합니다. 
오 그것은 놀랍습니다. 
두 가지 연산을 합니다. 
여러분이 알다시피, 여러분은 간단한 수를 할 수 있습니다, 네? 
빛은 기본적으로 나노 초 단위로 이동합니다. 
간단한 경험의 법칙 입니다. 
이제, 나노 초는, 10 의 마이너스 9 승 초 입니다. 
이것은 연산의 가치가 있는 2 기가 바이트를 합니다. 
1 기가는 10 의 9 승 입니다. 그래서 그것은 빛의 길이에  
두 연산을 합니다. 그것은 테이블 아래의 한 발자국으로부터 
테이블까지 빛 만큼 시간이 걸립니다. 
그것은 놀랍습니다. 
그래서 세계여서 여러분은 왜 효율성에 대해 걱정해야 합니까? 
자 문제는 문제들은 컴퓨터가 속도를 올리는 것 보다 
더 빠르게 성장한다는 것 입니다. 
저는 여러분에게 두 가지 예를 줄 것 입니다. 
저는 의학 화상 에서 일합니다. 
사실, 구탁 교수도 그렇습니다.

English: 
when I hurt-- yeah, try again.
When I turn this on switch on
in the lamp, at exactly the
same time, I'm going to hit a
key on my computer and start
it running.
OK.
In the length of time it takes
for the light to get from that
bulb to the table, this
machine processes two
operations.
Oh come on, that's amazing.
Two operations.
You know, you can do the
simple numbers, right?
[UNINTELLIGIBLE PHRASE]
Light travels basically a
foot in a nanosecond.
Simple rule of thumb.
Now, the nanosecond is what,
10 to the minus 9 seconds.
This thing does 2 gig
worth of operations.
A gig is 10 to the 9, so it
does two operations in the
length of time it takes light
to get from one foot off the
table down to the table.
That's amazing.
So why in the world do you
care about efficiency?
Well the problem is that the
problems grow faster than the
computers speed up.
I'll give you two examples.
I happen to work in
medical imaging.
Actually, so does Professor
Guttag.

Korean: 
제 연구 분야에서, 실시간 표현을 위해 우리가 초 당 약 100 개의 
이미지를 처리하고 싶은 것은 
매우 일반적 입니다. 
각 이미지는 그것 안에 약 백만 가지 요소를 가집니다. 
저는 그것의 어떤 것을 꺼내기 위해 일초에 
약 반 기가 데이터를 처리 해야 합니다. 
두 번째 예 입니다. 
아마도 그것이 약간 더 여러분을 집으로 이르게 할 것 입니다. 
저는 여러분이 모두 구글을 사용한다는 것을 확신합니다.
저는 여러분 단어장의 동사라고 생각해요, 그렇죠? 
이제, 구글은 처리 합니다 – 천 만 페이지? 
백 억 페이지? 
존?
저는 백 억 페이지가 제가 들은 마지막 수였다고 생각해요. 
제가 맞게 말했나요?
존 구탁 교수 : 저는 그것이 사실 지금은 
더 된다고 생각 해요. 
에릭 그림슨 교수 : 아마도 지금은 더 되겠지요. 
그러나, 논쟁을 위해서, 백 억 페이지 라고 합니다. 
여러분이 구글을 통해 특정 페이지를 찾기 위해 검색을 원한다고 
상상해 보세요. 
여러분은 그것을 곧 하길 원합니다. 
그리고 여러분은 잔인한 힘의 방법에서 그것을 할 것입니다.
여러분이 그 시간에 그 모든 페이지를 이를 수 있다고 상상하면요. 
자, 만약 여러분이 그것을 할 것 이라면, 여러분은 여러분이 
두 단계에서 페이지에서 찾는 것이 무엇인지 알아 낼 수 있어야 합니다. 
단계는 비교 또는 산술 연산에 있습니다. 
그것은 일어나지 않을 것 입니다, 맞나요? 
여러분은 단지 그것을 할 수 없을 것 입니다. 

English: 
In my in my area of research,
it's common for us to want to
process about 100 images a
second in order to get real
time display.
Each image has about a million
elements in it.
I've got to process about a half
a gig of data a second in
order to get anything
out of it.
Second example.
Maybe one that'll hit a little
more home to you.
I'm sure you all use Google, I'm
sure it's a verb in your
vocabulary, right?
Now, Google processes--
ten million?
Ten billion pages?
John?
I think ten billion was the
last number I heard.
Does that sound about right?
PROFESSOR JOHN GUTTAG:
I think it might
actually be more by now.
PROFESSOR ERIC GRIMSON:
Maybe more by now.
But let's, for the sake of
argument, ten billion pages.
Imagine you want to search
through Google to find a
particular page.
You want to do it in a second.
And you're going to just do it
the brute force way, assuming
you could even reach all of
those pages in that time.
Well, if you're going to do
that, you've got to be able to
find what you're looking for
in a page in two steps.
Where a step is a comparison
or an arithmetic operation.
Ain't going to happen, right?
You just can't do it.

English: 
So again, part of the point here
is that things grow-- or
to rephrase it, interesting
things grow at
an incredible rate.
And as a consequence, brute
force methods are typically
not going to work.
OK.
So that then leads to the
question about what should we
do about this?
And probably the obvious thing
you'll think about is, we'll
come up with a clever
algorithm.
And I want to disabuse
you of that notion.
It's a great idea if
you can do it,
The guy who--
I think I'm going to say this
right, John, right?
Sanjay?
Ghemawat?-- with a guy who was
a graduate of our department,
who is the heart and soul behind
Google's really fast
search, is an incredibly smart
guy, and he did come up with a
really clever algorithm about
how you structure that search,
in order to make it happen.
And he probably made a lot
of money along the way.
So if you have a great idea,
you know, talk to a good
patent attorney and get
it locked away.
But in general, it's hard
to come up with the
really clever algorithm.
What you're much better at doing
is saying how do I take
the problem I've got and map it
into a class of algorithms
about which I know and use the
efficiencies of those to try

Korean: 
그래서 다시, 여기서 중요한 부분은 그것이 증가한다는 것입니다. 
또는 그것을 다시 말해 보겠습니다. 흥미로운 것은 
엄청난 속도로 증가 합니다. 
그리고 결과적으로, 잔인한 힘의 방법은 전형적으로 
작동 하지 않을 것 입니다. 
네.
그래서 그것은 우리가 이것에 대해 무엇을 해야 하는가?  
에 대한 질문에 이르게 합니다.
그리고 아마도 여러분이 그것에 대해 생각하는 명백한 것은, 
우리가 현명한 알고리즘을 생산할 것이라는 것 입니다. 
그리고 저는 여러분에게 그 개념을 바로잡아 주고 싶습니다. 
그것은 여러분이 그것을 할 수 있다면 훌륭한 생각 입니다.
누가 – 저는 제가 이것을 제대로 말하고 있는지 모르겠네요, 존, 네? 
Sanjay? 
Ghemawat? – 우리 학부의 졸업생인 그 학생은, 
구글의 정말 빠른 검색 뒤의 심장이자 영혼 입니다.
그리고 엄청나게 똑똑한 학생 입니다, 그리고 그는 여러분이 그 검색을 어떻게 
구조화 하는지에 대한 정말로 현명한 알고리즘을 만들었습니다. 
그것이 일어나게 하기 위해서요. 
그리고 그는 아마도 그 방법으로 많은 돈을 벌었을 겁니다.
그래서 만약 여러분이 훌륭한 생각을 가지고 있다면, 
좋은 특허 변호사에게 말하고 그것을 잠가 두세요. 
그러나 일반적으로, 정말로 현명한 알고리즘을 
생산하는 것은 어렵습니다. 
여러분이 훨씬 더 잘 할 수 있는 것은 다음과 같이 말하는 것입니다. 
제가 가진 문제를 가지고 그것을 제가 알고있는 것에 대해 알고리즘이 
클래스로 만들고 그것이 작동하게 하는 방법을 알아내려고 시도하는 것들의 

Korean: 
효율성을 사용하는 것을 어떻게 할 수 있을까.  
그래서 우리가 하고 싶은 것은, 저는 그것을 말하는 또 다른 방법이, 
효율성은 정말 알고리즘에 선택에 대한 것이라고 생각합니다. 
그리고 우리는 여러분이 문제를 어떤 효율성의 알고리즘이 
클래스로 만드는 것을 돕고 싶습니다. 
그것이 우리의 목표 입니다. 
좋습니다.
그래서 이것을 하기 위해, 우리는 효율성에 대해 말하는 
약간 더 추상적인 방법이 필요 합니다.그래서 질문은, 
우리가 어떻게 효율성에 대해 생각 하는가? 입니다. 
전형적으로 우리가 측정하고 싶은 두 가지 것이 있습니다. 
공간 그리고 시간 입니다. 
천체 물리학 수업 같이 들리네요, 그렇죠?
이제, 공간은 보통 – 아, 그것을 다시 해 보겠습니다. 
우리가 공간에 대해 이야기 할 때, 우리가 보통 언급하는 것은, 
컴퓨터 메모리는 특정한 사이즈의 계산을 완료 하는데 
얼마나 걸리는가? 입니다. 

English: 
and figure out how
to make it work.
So what we want to do, is, I
guess another way of saying it
is, efficiency is really about
choice of algorithm.
And we want to help you learn
how to map a problem into a
class of algorithms of
some efficiency.
That's our goal.
OK.
So to do this, we need a little
more abstract way of
talking about efficiency, and
so, the question is, how do we
think about efficiency?
Typically there's two things
we want to measure.
Space and time.
Sounds like an astrophysics
course, right?
Now, space usually we--
ach, try it again.
When we talk about space, what
we usually refer to is, how
much computer memory does it
take to complete a computation
of a particular size?

English: 
So let me write that down, it's
how much memory do I need
to complete a computation.
And by that, I mean, not how
much memory do I need to store
the size of the input, it's
really how much internal
memory do I use up as I go
through the computation?
I've got some internal variables
I have to store,
what kinds of things do I
have to keep track of?
You're going to see the
arguments about space if you
take some of the courses that
follow on, and again, some
nice courses about that.
For this course, we're
not going to worry
about space that much.
What we're really going
to focus on is time.
OK.
So we're going to focus here.
And the obvious question I
could start with is, and
suppose I ask you, how long does
the algorithm implemented
by this program take to run?
How might I answer
that question?

Korean: 
그래서 제가 그것을 적어 보겠습니다, 그것은 제가 계산을 완료 하는데 얼마나 
많은 메모리가 필요한가 입니다. 
그리고 그것으로써, 제가 의미하는 것은, 제가 입력의 크기를 저장하기 위해 
얼마나 많은 메모리가 필요한가가 아닙니다. 그것은 정말로 제가 계산을 할 때 
제가 얼마나 많은 내부의 메모리를 사용 하는가 입니다. 
저는 제가 저장 해야 하는 어떤 내부의 변수들을 가지고 있습니다. 
제가 계속 해야 하는 것은 무엇 입니까? 
여러분은 공간에 대한 인자를 볼 것 입니다.
만약 여러분이 계속 되는 강의를 수강 한다면요, 그리고 다시, 
그것에 대한 어떤 좋은 강의들을 듣는다면요.
이 강의에서, 우리는 공간에 대해 그렇게 많이 
걱정하지 않을 것 입니다. 
우리가 정말로 초점을 맞출 것은 시간 입니다. 
네.
그래서 우리가 여기서 초점을 맞출 것 입니다. 
그리고 제가 시작할 수 있는 명백한 질문은, 그리고 제가 여러분에게 
질문 한다고 가정해 보세요, 이 프로그램에 의해 실행 되는 
알고리즘이 돌아 가는데 얼마나 많이 걸립니까? 
제가 그 질문에 어떻게 답할 수 있습니까? 

Korean: 
어떤 생각 있나요?   
네.
에릭 그림슨 교수 : 아, 학생은 저보다 앞서나갔네요. 
훌륭해요. 
답은, 입력의 수에 의존 하여 수학적인 
표현을 찾는 것 입니다. 
그것은 제가 가려고 하는 정확한 곳 입니다. 
고마워요. 
저는 더 간단한 답을 원했는데 즉, 그것을 실행합니다. 즉, 네 저는 
알고 있어요. 그것이 멍청하게 말하는 
것으로 보이나요, 네?
여러분이 상상할 수 있는 것들 중 하나는 단지 그것을 
시도 해 보는 것인데, 그것이 얼마나 오래 걸리는지 보세요. 
여러분은 그것 보다 모두 더 똑똑 합니다. 그러나 저는 왜 그것이 그렇게 
훌륭한 생각이 아닌지 지적하고 싶습니다. 
무엇보다도, 그것은 제가 선택한 입력이 
무엇인지에 의존합니다. 알겠죠? 
명백하게 알고리즘은 입력의 사이즈에 의존할 것 입니다.
그래서 이것은 그렇게 좋은 생각이 아닙니다. 
두 번째 것은, 그것은 제가 돌리고 있는 기계에 의존 합니다. 
만약 제가 PDP6 를 사용 한다면, 그것은 제가 에어 맥을 사용하는 것 보다 
더 긴 전체 시간이 걸릴 것 입니다. 
그렇죠?  
세 번째 것은, 그것은 제가 돌리고 있는 파이썬의 
버전에 의존 합니다. 
파이썬의 실행자가 얼마나 현명한지에 의존 합니다. 
네 번째 것은, 그것은 제가 그것을 하고 있는 
프로그래밍 언어에 의존합니다. 그래서 저는 경험에 
의거하여 그것을 할 수 있지만, 그것을 전형적으로 하고 싶지 않습니다. 
그것은 그것에서 얻기 위한 그렇게 훌륭한 방법이 아닙니다.

English: 
Any thoughts?
Yeah.
STUDENT: [INAUDIBLE]
PROFESSOR ERIC GRIMSON:
Ah, you're jumping
ahead of me, great.
The answer was, find a
mathematical expression
depending on the number
of inputs.
It was exactly where
I want to go.
Thank you.
I was hoping for a simpler
answer, which is, just run it.
Which is, yeah I know,
seems like a dumb
thing to say, right?
One of the things you could
imagine is just try it on and
input, see how long it takes.
You're all cleverer than that,
but I want to point out why
that's not a great idea.
First of all, that depends on
which input I've picked.
All right?
Obviously the algorithm is
likely to depend on the size
of the input, so this
is not a great idea.
Second one is, it depends on
which machine I'm running on.
If I'm using a PDP6, it's going
to take a whole lot
longer than if I'm
using an Air Mac.
All right?
Third one is, it may depend
on which version
of Python I'm running.
Depends on how clever the
implementer of Python was.
Fourth one is, it may depend on
which programming language
I'm doing it in.
So I could do it empirically,
but I don't want to do that
typically, it's just not a
great way to get at it.

Korean: 
그리고 그래서 사실, 우리가 원하는 것은 
정확하게 어린 숙녀가 말한 것 입니다. 
저는 다음 질문을 할 것 입니다.
그것은 – 제가 그것을 적겠습니다 – 
입력 사이즈의 함수로써 필요한 기본적인 단계의 수는 무엇 입니까? 
그것은 우리가 말하려고 노력하는 질문 입니다. 
우리가 이것을 할 수 있으면, 이것은 좋습니다.
왜냐하면 첫 번째로, 그것은 제가 어떤 기계에서 돌리고 있는지에 대한 
어떤 질문들을 없애 버립니다. 그것은 근본적으로 이 문제가 얼마나 어려운지에 
대해 말하고 있습니다. 그리고 두 번째 것은, 
그것은 구체적으로 입력의 관점에서 그것을 할 것 입니다. 
그것은 제가 걱정했던 것 중 하나 입니다. 
네.
그래서 이것을 하기 위해, 우리는 몇 가지를 해야할 것입니다. 
좋아요, 첫 번째 것은, 우리는 입력 사이즈로 무엇을 의미합니까? 

English: 
And so in fact, what we
want is exactly what
the young lady said.
I'm going to ask the following
question, which is-- let me
write it down-- what is the
number of the basic steps
needed as a function
of the input size?
That's the question we're going
to try and address.
If we can do this, this is good,
because first of all, it
removes any questions about what
machine I'm running on,
it's talking about
fundamentally, how hard is
this problem, and the second
thing is, it is going to do it
specifically in terms
of the input.
Which is one of the things
that I was worried about.
OK.
So to do this, we're going to
have to do a couple of things.
All right, the first one is,
what do we mean by input size?

Korean: 
그리고 불행하게도, 이것은 문제에 의존 합니다. 
그것은 제가 인자로 어떤 크기의 정수를 주었는지 일 수 있습니다. 
그것은 리스트가 얼마나 긴지 일 수 있습니다. 
만약 제가 리스트 또는 튜플을 처리 한다면요. 
그것은, 그 안에 얼마나 많은 비트가 
있는지 알 수 있습니다. 
그래서 그것은 – 그것은 우리가 간단히 우리가 입력  
크기로 사용 하는 것을 구체화 하는 것에 대하여 분명 해야 하는 곳 입니다. 
그리고 우리는 그것을 수학적으로 어떤 수로 특징 지으려고 합니다.
또는 어떤 변수로요, 리스트의 크기, 인티져의 사이즈 같은 것이 
우리가 하고 싶은 것일 것 입니다. 
우리가 걱정 하는 두 번째 것은, 기본적인 단계가 무엇입니까? 
네, 만약 제가 그것의 내부에 계산의 전체적인 많은 것을 묻는다면, 
저는 말할 수 있습니다. 와우, 이 프로그램은 
한 단계에서 동작합니다. 
불행하게도, 그 한 단계는 델파이의 오라클을 부릅니다. 
그리고 답을 다시 돌려 줍니다. 
아마 여러분이 원하는 것이 아닐 것 입니다.  
우리는 전형적으로 기본적인 단계로써 기계가 딸려 있는 
내장 된 초기 요소들을 사용 할 것 입니다. 
또는 그것을 말하는 또 다른 방법은, 우리는 기본적인 단계로써 
일정한 시간 안에 돌아 가는 이 연산들을 사용할 것 입니다.
그래서 산술 연산을요. 
비교 같은 것이 있습니다. 
메모리 접근, 그리고 사실 우리가 여기서 하려고 

English: 
And unfortunately, this depends
on the problem.
It could be what's the size of
the integer I pass in as an
argument, if that's what
I'm passing in.
It could be, how long is the
list, if I'm processing a list
or a tuple It could
be, how many bits
are there in something.
So it-- that is something where
we have to simply be
clear about specifying what
we're using as input size.
And we want to characterize it
mathematically as some number,
or some variable rather, the
length of the list, the size
of the integer, would be the
thing we'd want to do.
Second thing we've got
to worry about is,
what's a basic step?
All right, if I bury a whole lot
of computation inside of
something, I can say, wow, this
program, you know, runs
in one step.
Unfortunately, that one step
calls the Oracle at Delphi and
gets an answer back.
Maybe not quite what you want.
We're typically going to use
as basic steps the built-in
primitives that a machine
comes with.
Or another way of saying it is,
we're going to use as the
basic steps, those operations
that run in constant time, so
arithmetic operations.
Comparisons.
Memory access, and in fact one
of the things we're going to

English: 
do here, is we're going to
assume a particular model,
called a random access model,
which basically says, we're
going to assume that the length
of time it takes me to
get to any location in
memory is constant.
It's not true, by the way, of
all programming languages.
In fact, Professor Guttag
already talked about that, in
some languages lists take
a time linear with the
length to get to it.
So we're to assume we can get
to any piece of data, any
instruction in constant time,
and the second assumption
we're going to make is that the
basic primitive steps take
constant time, same amount
of time to compute.
Again, not completely true,
but it's a good model, so
arithmetic operations,
comparisons, things of that
sort, we're all going to assume
are basically in that
in that particular model.
OK.
Having done that, then, there
are three things that we're
going to look at.
As I said, what we want to do
is, we want to count the

Korean: 
하는 것들 중 하나는, 우리는 특정한 모델을 가정할 것 입니다.
그것은 랜덤 접근 모델 입니다.
그것은 기본적으로 말합니다. 우리는 제가 메모리의 어떤 위치로 그것을 가져 오는데
 
798
00:43:20,500 --> 00:43:23,449
걸리는 시간의 길이는 일정 하다고 가정할 것 입니다. 
그런데 그것은 모든 프로그래밍 언어에서 옳지 않습니다. 
사실, 구탁 교수는 이미 그것에 대해 이야기 했습니다.
어떤 언어에서 리스트는 그것을 얻기 위한 
길이로 선형 시간을 갖습니다. 
그래서 우리는 우리가 어떤 데이터를 가져 와서, 일정한 시간에 
어떤 명령을 할 수 있다고 가정 합니다. 그리고 우리가 하려고 하는 
두 번째 가정은 기본적인 초기 요소들은 일정한 시간, 
계산하는 데 같은 양의 시간을 가진 다는 것 입니다.
다시, 완벽하게 옳지는 않지만, 그것은 좋은 모델 입니다. 
그래서 산술 연산, 비교, 그러한 종류의 것이 있습니다.  
우리가 모두 가정하려고 하는 것은 기본적으로 
그 특정한 모델에서 거기에 있습니다. 
네.
다 하고 나면, 그러면, 우리가 보아야 할 
세 가지 것들이 있습니다.
제가 말한 대로, 우리가 하고 싶은 것은, 우리는 

English: 
number of basic steps it takes
to compute a computation as a
function of input size.
And the question is, what
do we want to count?
Now, one possibility
is to do best case.
Over all possible inputs to
this function, what's the
fastest it runs?
The fewest, so the minimum,
if you like.
It's nice, but not particularly
helpful.
The other obvious one to
do would be worst case.
Again, over all possible inputs
to this function,
what's the most number of
steps it takes to do the
computation?
And the third possibility, is
to do the expected case.
The average.
I'm going to think
of it that way.
In general, people focus
on worst case.
For a couple of reasons.
In some ways, this would be
nicer, do expected cases, it's
going to tell you on average how
much you expect to take,
but it tends to be hard to
compute, because to compute

Korean: 
입력 크기의 함수로써 계산을 컴퓨팅 하는데
걸리는 기본적인 단계의 수를 세려고 합니다. 
그리고 질문은, 우리가 세려고 하는 것은 무엇 입니까? 입니다. 
이제, 한 가지 가능성은 최고의 경우를 하는 것 입니다. 
이 함수의 모든 가능한 입력에서, 그것이 돌리는 
가장 빠른 것은 무엇 입니까? 
가장 적은 것, 그래서 최소의 것을 말합니다. 여러분이 원한다면요.
그것을 좋습니다, 그러나 특별히 도움되지는 않습니다. 
우리가 하는 또 다른 명백한 것은 최악의 경우 입니다. 
다시, 이 함수에서 모든 가능한 입력에서, 그것이 계산을 하는데  
걸리는 가장 많은 단계의 수는 무엇 입니까?
그리고 세 번째 가능성은, 예측 된 경우를 하는 것 입니다. 
평균 입니다. 
저는 그것을 그 방법으로 생각할 것 입니다. 
일반적으로, 사람들은 최악의 경우에 초점을 맞춥니다. 
몇 가지 이유로 그렇습니다. 
어떤 방법에서, 이것은 더 좋습니다. 예측된 경우들을 하세요.
그것은 여러분에게 평균적으로 여러분이 얼마나 걸린다고 예상했던 것을 말해 줍니다. 
그러나 그것은 계산하기 어려운 경향이 있습니다.

English: 
that, you have to know a
distribution on input.
How likely are all the inputs,
are they all equally likely,
or are they going to depend
on other things?
And that may depend on the
user, so you can't
kind of get at that.
We're, as a consequence, going
to focus on worst case.
This is handy for a
couple of reasons.
One, it means there
are no surprises.
All right?
If you run it, you have a sense
of the upper bound,
about how much time it's going
to take to do this
computation, so you're not
going to get surprised by
something showing up.
The second one is, a lot of the
time, the worst case is
the one that happens.
Professor Guttag used an example
of looking in the
dictionary for something.
Now, imagine that dictionary
actually has something that's
a linear search to go through
it, as opposed to the hashing
he did, so it's a list,
for example.
If it's in there, you'll find
it perhaps very quickly.
If it's not there, you've got
to go through everything to
say it's not there.
And so the worst case often
is the one that shows up,
especially in things
like search.
So, as a consequence, we're
going to stick with the worst
case analysis.
Now, I've got two
minutes left.

Korean: 
왜냐하면 그것을 계산하기 위해, 여러분은 입력에서 분배를 알아야 합니다. 
모든 입력이 어떻습니까, 그것들이 모두 동등 합니까, 
또는 그것들이 다른 것들에 의존 할 것 입니까? 
그리고 그것은 사용자에 의존할 것 입니다. 
그래서 여러분은 그것에서 얻을 수 없습니다. 
우리는, 결과적으로, 최악의 경우에 초점을 맞출 것 입니다. 
이것은 몇 가지 이유로 간편 합니다. 
하나는, 그것은 놀랄 만한 것이 없다는 것을 의미 합니다. 
그렇죠?
만약 여러분이 돌리면, 여러분은 상한의 감각을 가집니다.
 그것이 이 계산을 하는데 얼마나 많은 시간이 걸리는지에 대해서요.
그래서 여러분은 어떤 것이 나타나는 것에 대해 놀라지 않을 것 입니다.  
두 번째 이유는, 많은 시간 입니다. 
최악의 경우는 그것이 일어 나는 것 입니다. 
구탁 교수는 어떤 것을 위한 dictionary에서 
찾는 것의 예를 사용 했었습니다. 
이제, dictionary 가 사실 그것을 찾기 위한 선형 검색인 것을 
가진다고 상상해 보세요. 그가 했던 해싱과 반대로요. 그래서 그것은 리스트 입니다.
예를 들어서요. 만약 그것이 거기에 있으면, 
여러분은 그것이 아마 매우 빠를 것이라는 것을 알 수 있습니다. 
만약 그것이 거기 있지 않으면, 여러분은 그것이 거기 있지 않다고 
말하기 위해 모든 것을 살펴 볼 것 입니다. 
그리고 그래서 최악의 경우는 종종 나타내는 것 입니다.  
특히 검색 같은 것에서요. 
그래서, 결과적으로, 우리는 최악의 경우 
분석을 고수할 것 입니다. 
이제, 저는 2 분이 남았네요. 

English: 
I was going to start showing
you some examples, but I
think, rather than doing that,
I'm going to stop here, I'm
going to give you two minutes
back of time, but I want to
just point out to you that we
are going to have fun next
week, because I'm going to show
you what in the world
that has to do with
efficiency.
So with that, we'll
see you next time.

Korean: 
저는 여러분이게 몇 가지 예를 보여 주려고 했었습니다.
그러나 그것을 하는 것 보다는 여기서 멈추는 것이 좋을 거라고 생각 되네요.
저는 여러분에게 2 분의 시간을 돌려 주겠습니다. 그러나 저는 여러분에게 
우리가 다음주에 재미있게 놀 것 이라고 지적하고 싶습니다.
왜냐하면 저는 여러분에게 세계에서 효율성과 관련 있는것을 
보여줄 것 이기 때문입니다.  
그래서 그것을 가지고, 우리는 다음 시간에 보겠습니다. 
