
Korean: 
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다.
이 강의의 한국어자막은 www.snow.or.kr 자원활동가들에 의해 작성되었습니다. 다음 내용은 저작권으로 
보호되어 있습니다. 
MIT OCW(무료공개강좌) 는 계속해서 고품질의 교육자원을  
무료로 제공함으로써 여러분을 도와줄 것입니다. 
추가적인 MIT 코스의 자료를 보거나
기부하시려면 ocw.mit.edu을 
방문해주세요.
좋아요, 저는 오늘 이야기 하면서 시작할 것입니다, 
그래서 우리가 하고 있는 것이 무엇인가요? 
우리가 지난 강의들 동안 무엇을 했나요? 
그리고 저는 여러분에게 우리가 한 것이 무엇인지 말하고 싶군요, 
우리는 많은 프로그래밍 기본 요소들의 개요를 잡았습니다. 
우리가 코드를 쓸 때 필요한 많은 기본적인 
요소들을요.  
그리고 저는 그것을 여러분에게 강조하고 싶습니다. 왜냐하면 
우리가 돌아 가서 그것들을 살펴볼 것이기 때문입니다. 
그래서 우리는 세 가지 다른 것들을 
살펴 보았습니다.  
우리는 데이터에 대해 이야기 했고, 작업들에 대해 이야기 했고, 
명령문이나 식에 대해 이야기 했어요. 

English: 
The following 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: All right, I'm
going to start today
by talking about,
so what have we been doing?
What have we actually done
over the last few lectures?
And I want to suggest
that what we've done
is, we've outlined a lot of the
basic elements of programming.
A lot of the basic
elements we're
going to need to write code.
And I want to just highlight
it for you because we're going
to come back and look at it.
So I'm going to
suggest that we've
looked at three different
kinds of things.
We've talked about data,
we've talked about operations,
and we've talked about
commands or statements.

English: 
All right?
Data's what we expect.
It's our way of
representing fundamentally
the kinds of information
we want to move around.
And here, I'm going to
suggest we've seen numbers,
we've seen strings,
and I'm going
to add Booleans here as well.
They're a third kind
of value that we
saw when we started
talking about conditions.
We saw, associated with
that primitive data,
we have ways of taking
data in and creating
new kinds of data out, or
new versions of data out,
so we have operations.
Things like addition
and multiplication,
which we saw not only
apply to numbers,
but we can use them
on things like strings
and we're going to come
back to them again.
Can't use them on Booleans, they
have a different set of things.
They do things like AND, and OR.
And of course there's a
bunch of other ones in there,
I'm not going to
put them all up,
but we're building up a little
collection, if you like,
of those operations.
And then the main
thing we've done
is, we've talked about commands.
So I'm going to suggest we've
seen now four different things.

Korean: 
그렇죠? 
데이터는 우리가 예상하는 것입니다. 
그것은 근본적으로 우리가 이동하길 원하는 
정보를 나타내는 방법입니다. 
그리고 여기서, 저는 우리가 수와 문자열을 보았다고 말하고 싶군요, 
그리고 또한 Boolean도 추가해야죠. 
그들은 조건문에 대해 이야기 할 때 우리가 보았던 
세 번째 값입니다. 
우리는, 초기 데이터와 관련하여, 데이터를 가져 오고 새로운 데이터를 만들거나  
데이터의 버전을 만드는 방법을 가지고 있고, 
작업들을 가지고 있습니다. 
덧셈과 곱셈과 같은 것들은 숫자에만 적용되는 것이 아니라 
문자열과 같은 것에도 적용됩니다.
그리고 우리는 다시 그것들로 돌아 올 것입니다. 
그것들을 Boolean에 사용할 수 없습니다,  
그것들은 다른 것이에요. 
그것들은 AND와 OR 같은 것을 합니다. 
그리고 물론 거기에는 다른 것들 것 있죠, 
저는 그것들을 모두 다루지는 않을 것이지만, 
우리는 이 연산들의 작은 컬렉션을 구축할 것입니다.
그리고 우리가 한 주요한 것은, 
우리는 명령문에 대해 이야기 했어요. 
그래서 저는 이제 네 가지 다른 것을 보았다고 생각해요. 

English: 
We've seen assignment, how
to bind a name to a value.
We've seen input and output.
Print for output, for example,
and raw input for input.
We've seen conditionals, or
said another way, branches,
ways of changing
the flow of control
through that sequence of
instructions we're building up.
And the last thing we
added were loop mechanisms.
And here we saw, while.
It's the first
example we've seen.
So what've we done so far?
Now, interestingly,
this set of instructions
was actually quite
powerful, and we're
going to come back to
that later on, in terms
of what we can do with it,
but what we've really done
is, given that basis,
we're now talking about,

Korean: 
우리는 대입, 값에 이름을 바인드 하는 방법을 보았어요.  
우리는 입력과 출력을 보았어요.
예를 들어, 출력을 위한 프린트와 입력을 위한 원 입력을요. 
우리는 조건문을 보았어요, 다른 방법으로 말하면, 
우리가 만든 명령문들의 순서를 통해  
제어의 흐름을 바꾸는 방법인 branch도 보았어요.
그리고 우리가 추가 했던 것은 루프 매커니즘 입니다.  
그리고 여기서 우리는 보았죠, 와우. 
그것은 우리가 본 첫 번째 예제입니다. 
그래서 지금까지 우리가 무엇을 했나요? 
이제, 흥미롭게, 이것은 사실 꽤 강력한 명령문들의 세트입니다, 
그리고 우리는 나중에 그것으로 돌아 올 것입니다, 
그것으로 우리가 할 수 있는 것의 관점에서요, 그러나 우리가 정말 할 수 있는 것은, 
그 기본이 주어졌을 때, 우리는 어떻게 일반적인 코드 패턴을 쓰는지, 

Korean: 
특정한 문제를 풀기 위해 쓰는 방법들에 대해 
이야기하려고 합니다. 
그래서 제가 여러분이 하길 바라는 것은, 이러한 기초들을 마음 속에 새기세요. 
우리는 그 기초들로 많은 것을 할 수 있어야 합니다. 그러나 
우리가 정말 관심 있는 것은 여기에서 다른 전체 것들로 커지지는 않아요. 
우리는 그것들에 함께 일반적인 
템플릿들을 더할 거에요. 
그리고 우리는 오늘 그것들을 할 것입니다.  
우리가 하고 있는 두 번째 것, 제가 여러분에게 강조하고 싶은 것은, 
우리는 적기 보다는 대부분 말로 해왔지만 
우리는 좋은 스타일에 대해 이야기 했습니다. 
좋은 프로그래밍 스타일을요.  
그렇죠? 
여러분이 이것들을 함께 다룰 때, 
정말 좋은 코드를 주기 위해 우리가 해야 하는 것들을요. 
그리고 여러분은 이런 것들을 함께 모을 수 있어야 합니다. 
여러분에게 몇 가지 예제들을 주겠어요. 
우리는 무엇에 대해 이야기 했나요? 
우리는 여러분이 코드에서 무엇을 하는지 강조하기 위해 
comment를 사용하는 것에 대해 이야기 했습니다. 
그것은 디버그를 쉽게 만듭니다. 우리는 타입 지시에 대해서도 이야기 했어요. 
여러분이 연산자들을 적용하기 전에, 피연산자의 타입을 검사해야 한다는 개념이죠. 
코드에 맞는 타입이라는 것을 확실히 하기 
위해서요. 
우리는 좋은 변수 이름의 서술적인 사용에 대해서도 이야기 했어요. 

English: 
how do we write common
patterns of code,
how do we write
things that solve
particular kinds of problems.
So what I want you to do,
is to keep in mind, those
are the bases, we
ought to be able to do
a lot with that bases, but
what we're really interested in
is not filling out a whole
bunch of other things in here,
but how do we put them
together into common templates.
And we're going
to do that today.
Second thing we've
been doing, I want
to highlight for you is, we've
along the way, mostly just
verbally rather than
writing it down,
but we've been talking
about good style.
Good programming style.
All right?
Things that we
ought to do, as you
put these pieces
together, in order
to give you really good code.
And you should be
collecting those together.
Give you some examples.
What have we talked about?
We've talked about things
like using comments
to highlight what you're
doing in the code,
to make it easier to debug.
We talked about type
discipline, the notion
that you should check
the types of operands
before you apply operators to
them, to make sure that they're
what the code is expecting.
We talked about descriptive
use of good variable names,

English: 
as a way, in essence, of
documenting your code.
The fourth one we talked
about was this idea
of testing all possible branches
through a piece of code,
if it's got conditionals
in it, to make sure
that every possible
input is going
to give you an output that
you actually want to see.
So, you know, you can start
writing your own, kind of,
Miss Manners book,
if you like, I mean,
are what are good
programming, you
know-- I wonder what
you'd call them,
John, good programming hygiene?
Good programming style?
Good programming
practices?-- Things that you
want to do to write good code.
OK.
What we're going to
do today is, we're
going to start now building
up, beyond just these pieces,
although they're valuable, to
start creating two things: one,
common patterns of
code that tackle
certain classes of
problems, and secondly we're
going to talk about tools you
can use to help understand
those pieces of things.
OK.
So last time around, we talked
about, or introduced if you
like, iterative programs.

Korean: 
필수적으로, 여러분의 코드를 기록하는 것도요. 
우리가 이야기한 네 번째 것은 코드를 통해 모든  
가능한 branch들을 테스트하는 생각이었습니다. 그것이 그것 안에 조건문을 가지면, 
모든 가능한 입력이 여러분에게 
여러분이 실제 보기를 원하는 출력을 줍니다. 
그래서, 여러분은 여러분의 규칙의 책 같은 것을 쓸 수 있어요, 
제가 말하는 것은, 좋은 프로그래밍 입니다. – 
저는 여러분이 그것들을 뭐라고 부르는지 궁금하네요, 
존, 좋은 프로그래밍 위생이라고 하나요? 
좋은 프로그래밍 스타일인가요? 
좋은 프로그래밍 연습? – 여러분이 원하는 것은 
좋은 코드를 쓰는 것입니다. 
좋아요. 
오늘 우리가 하려는 것은, 우리는 이제 구축을 시작할 거에요,
이것들을 넘어서, 몰론 그것들은 중요하지만, 
두 가지를 만들어 볼게요: 하나는, 
어떤 문제들의 클래스를 다루는 일반적인 코드의 패턴이고, 
두 번째로 우리는 이러한 것들을 이해하도록 돕기 위해  
여러분이 사용할 수 있는 도구들에 대해 이야기 할 것입니다.
좋아요. 
지난 시간에, 우리는 반복 프로그램에 대해 이야기 했어요, 
그것을 소개했죠. 

English: 
And I want to generalize
that for a second,
because we're going to come
back and use this a lot.
And I want to do a very
high-level description
of what goes into an
iterative program,
or how I would think
about this, all right?
And I know if John disagrees
with me he'll tell me,
but this is my way
of thinking about it.
If I want to try and
decide how to tackle
a problem in an iterative
matter, here the steps
I'm going to go through.
First thing I'm
going to do, is I'm
going to choose a variable
that's going to count.
What I meant-- what in the
world do I mean by that?
I'm thinking about
a problem, I'm
going to show you an example
in a second, first thing I'm
going to do is say,
what is the thing that's
going to change every time I run
through the same set of code?
What is counting my way
through this process?
Now I'm putting count
in double quotes,
not to make it a string, but to
say, this is count generically.
It could be counting one by
one through the integers,
it could also be taking
a collection of data

Korean: 
그리고 잠깐 그것을 일반화하고 싶군요. 왜냐하면 
우리는 다시 돌아와서 이것을 많이 사용할 것이기 때문이죠. 
그리고 저는 반복 프로그램으로 가는 것, 또는 우리가 이것에 대해 어떻게 생각하는지에 대한 
매우 높은 수준의 설명을 원합니다, 
알겠죠? 
그리고 저는 존이 저와 동의하지 않는 다는 것을 알아요 그가 저에게 말할 것입니다, 그러나 이것은 
그것에 대해 생각하는 저의 방법입니다. 
반복적인 문제에서 문제를 다루는 방법을 시도하고 결정하길 원한다면, 
여기 제가 하려는 단계들이 있습니다. 
제가 하려는 첫 번째 것은, 저는 중요한 변수를 
선택할 것입니다. 
제가 말하는 것은 – 제가 그것으로 무엇을 의미하죠? 
저는 문제에 대해 생각할 것입니다, 저는 여러분에게 곧 예를 보여줄 거에요,
 
119
00:05:39,529 --> 00:05:41,739
제가 하려는 첫 번째 것은, 제가 같은 코드 세트를 통해 
실행 할 때 마다 
매번 바뀌는 것들은 무엇이죠? 
이 프로세스를 통해 제 방법은 무엇을 세죠?  
이제 저는 큰 따옴표를 넣을 것이에요, 문자열로 만들기 이해서가 아니라, 
이것은 일반적으로 세는 것입니다. 
그것은 인티져를 통해 하나씩 세는 것일 수도 있고,
데이터의 컬렉션을 가지는 것과 하나씩 그것들을 

English: 
and going through
them one by one.
It could be doing counting
in some other mechanism.
But what's the
variable I want to use?
Second thing I do, I
need to initialize it.
And I need to initialize
it outside of the loop.
That is, where do
I want to start?
And I need to make sure I have
a command that sets that up.
The third thing
I'm going to do, is
I need to set up
the right end test.
How do I know when I'm
done with the loop?
And obviously, that
ought to involve
the variable in some
way, or it's not
going to make a lot of sense,
so this includes the variable,
since that's the
thing that's changing.
All right.
The fourth thing
I'm going to do,
is I'm going to then
construct the block of code.
And I want to remind
you, that block of code
is a set of instructions,
the same set of instructions
that are going to be done
each time through the loop.

Korean: 
살펴 보는 것일 수도 있어요. 
그것은 어떤 다른 매커니즘에서 세는 것을 할 수도 있습니다. 
그러나 제가 사용할 변수는 무엇이죠? 
제가 하는 두 번째 것은, 저는 그것을 초기화해야 합니다.  
그리고 루프 밖에서 그것을 초기화해야 합니다. 
즉, 저는 어디서 시작해야 하죠? 
그리고 저는 그것들을 만든 명령문을 가지고 있다는 것을 확실히 해야 합니다. 
제가 하려는 세 번째 것은, 
저는 옳은 마지막 테스트를 만들어야 합니다. 
제가 루프를 다 했을 때 제가 어떻게 알 수 있죠? 
그리고 명백히, 그것은 그 방법에서 그 변수를 포함해야 합니다, 
그것은 말이 안 되는 것이 아니에요, 
이것은 변수를 포함합니다, 그것이 바뀌는 것이기 때문이죠.
이것은 변수를 포함합니다, 그것이 바뀌는 것이기 때문이죠.
좋아요. 
제가 하려는 네 번째 것은, 
저는 코드의 블록을 만들어야 합니다. 
그리고 여러분에게 코드의 블록은 명령문들의 세트, 
루프를 통해 각각 행해 지는 명령문들과 같은 세트라는 것을 
상기시키고 싶습니다. 

English: 
All that's going to change,
is the value the variable
or the value of some
data structures.
And remind you that
inside of here,
I'd better be
changing the variable.
All right, if that variable
that's counting is not
changing, I'm going to be
stuck in an infinite loop,
so I ought to
[UNINTELLIGIBLE PHRASE] that ,
right, expect
somewhere in there,
a change of that variable.
All right?
And then the last
thing I want to do,
is just decide, you know,
what do I do when I'm done.
OK.
I know.
It looks boring.
But it's a structure
of the things
I want to think about
when I go through trying
to take a problem and mapping
it into a iterative program.
Those are the things I
want to see if I go along.
All right.
So let me give you an example.
I'm given an integer
that's a perfect square,
and I want to write a little
piece of code that's going
to find the square root of it.
All right, so I'm
cheating a little,
I know it's a perfect
square, somebody's
given it to me, we'll come back
in a second to generalizing it,

Korean: 
바뀌는 모든 것들은 값 변수 또는 
어떤 데이터 구조의 값입니다. 
그리고 여기 안에서 그것을 상기해 보세요, 저는 변수를 
바꾸는 것이 나을 것입니다. 
좋아요, 그 세는 변수가 바뀌지 않으면, 
저는 무한 루프에 빠지게 됩니다, 그래서 저는  
좋아요, 거기 어딘가에 그 변수의 
변화가 있겠죠. 
알겠죠? 
그리고 제가 하려는 마지막 것은, 제가 다 했을 때 
무엇을 할지 결정하는 것입니다.  
좋아요. 
저는 알아요. 
이것은 지루해 보이죠. 
그러나 그것은 제가 문제를 가지고 그것을 반복 프로그램으로 
연관시키려고 살펴 볼 때에 대해 생각하는 것의 
구조 입니다. 
이것들은 제가 한다면 보길 원하는 것들이죠. 
좋아요.  
여러분에게 예제를 줄게요. 
완벽한 제곱인 인티져가 주어졌습니다. 그것의 제곱근을 찾기 위한 코드를 짭시다
우리는 곧 이것을 일반화하기 위해 돌아 올 것입니다, 제가 예제를 풀기 위해 사용한 단계들을
쓰려고 합니다. 
좋아요, 약간 유리한 상황이죠, 저는 이 숫자가 완벽한 제곱이라는 것을 알아요, 
누군가가 저에게 그렇게 줬어요, 우리는 곧 이것을 일반화하기 위해 돌아 올 것입니다, 

Korean: 
제가 그것을 보여주기 위해 사용할 단계들은 
무엇이죠?  
이 단계들에 대해 생각해 보세요. 
여기 그것을 하는 쉬운 방법이 있어요.  
1에서 시작해 봅시다. 
저는 x의 제곱근을 찾으려고 합니다. 
저는 x의 제곱근을 찾으려고 합니다. 
1에서 시작해 봅시다. 
그것을 제곱하세요. 
그것이 x 보다 크지 않으면, 2로 하세요. 
그것을 제곱하세요. 
그것이 x 보다 크지 않으면, 3으로 하세요.
그것을 제곱하세요. 
그리고 계속 하세요. 그 인티져들 중 하나의 제곱이 크거나 같을 – 
미안해요, x 보다 클 때 까지만요. 
좋아요. 제가 왜 이것을 하죠? 
제가 x 보다 커지면, 
저는 제가 원하는 곳을 지나 왔어요. 
그리고 명백히, 제가 그것의 제곱이 x와 같은 것을 얻었을 때, 
저는 원하는 답을 얻습니다, 그리고 그것을 차버립니다. 
제가 한 것을 누가 알죠?   
저는 세기 위해 사용하는 것을 식별했어요, 
어떤 변수가 인티져들을 셀 것을요, 
저는 마지막 테스트를 식별했어요, 
그것은 그 제곱이 제가 찾는 것 보다 클 때, 
제가 기본적으로 루프 안에서 원하는 것을 식별합니다, 
그것은 단지 그 변수를 바꿉니다, 그리고 저는 제가 다 했을 때 
원하는 것을 말하지 않았군요, 필수적으로 

English: 
so what would the steps be that
I'd use to walk through it?
Well if you think
about these steps,
here's an easy way to do it.
Let's start at 1.
Let's call x the
thing I'm trying
to find the square root of.
Let's start at 1.
Square it.
If it's not greater
than x, take 2.
Square it.
If it's not greater
than x, take 3.
Square it.
And keep going, until the
square of one of those integers
is greater than or equal to--
sorry, just greater than x.
OK, why am I doing that?
When I get greater than x,
I've gone past the place
where I want to be.
And obviously, when
I get to something
whose square is equal to x,
I've got the answer I want,
and I kick it out.
So who knows what I've done?
I've identified the thing
I'm going to use to count,
something some variable is going
to just count the integers,
I've identified
the end test, which
is when that square is bigger
than the thing I'm looking
for, I've identified
basically what I want
to do inside the
loop, which is simply
keep changing that
variable, and I
didn't say what I want
to do when I'm done,

Korean: 
답을 프린트 합니다.
좋아요. 그래서 어떻게 제가 이 코드를 하죠? 
자, 여러분은 생각할 것입니다, 그냥 점프해서 코드를 씁시다, 
저는 꽤 이것을 하길 원하지 않아요, 왜냐하면 여러분에게 
코드를 구조화하는 방법에 대해 생각하기 위한 중요한 다른 도구들을 
보여주려고 하거든요, 그리고 그것은 
플로 차트라는 것입니다. 
이제, 
구탁 교수와 내 나이는, 불행히도 
플로 차트를 다시 생각해 보세요 – 심슨에서, 
그들이 말하는 것처럼, 예전으로, 1960년대로, 존, 그렇죠? 
정말 좋은 프로그래머들은 이 환상적인 작은 플라스틱 스텐실을 가지고 있어요, 
저도 찾으려고 노력했었지만, 찾을 수 없었어요. 
그것은 작은 잘래 낸 모양의 작은 스텐실입니다, 여러분은 플로 차트를 그리기 위해 사용했죠, 
저는 곧 여러분에게 보여 줄 것입니다, 
그리고 여러분은 그 안의 모든 펜들이 있는 주머니 옆에 끼웁니다, 
여러분의 벨트도 또한 이에 관한 것이에요,   
그리고 여러분의 안경은 이렇게 두꺼워요, 우리는 컴퓨터만 아는 괴짜만 남았군요, 
우리는 대부분 이것들을 박물관에 보관합니다, 
그런데 그것은 여러분이 플로 차트를 그리는 것이에요.
나쁜 유머에도 불구하고, 우리는 여기서 
같은 것을 할 거에요. 
우리는 여기서 같은 것을 할 것입니다, 우리는 실제 이것이 작동하도록 하는 것으로 
해야 하는 것의 차트를 
그릴 것입니다. 
그래서 여기 제가 설명한 것을 캡쳐하기 위해 

English: 
essentially print
out the answer.
OK, so how can I code this up?
Well, you might think,
let's just jump in
and write some code, I don't
want to quite do that though,
because I want to show
you another tool that's
valuable for thinking about
how to structure the code,
and that is a something
called a flow chart.
Now.
People of Professor
Guttag's and my age,
unfortunately remember flow
charts back-- as they say,
on the Simpsons, back in the
day, back in the 1960's, John,
right?-- really good programmers
had these wonderful little
plastic stencils, I
tried to find one,
I couldn't find it It's a little
stencil with little cut-out
shapes on it, that you
used to draw flow charts,
I'm going to show
you in a second,
and you tucked it right in here
next to your pocket protector
with all your pens
in it, you know,
so, your belt was
also about this high,
and your glasses were
this thick, you know,
we have a few of
those nerds left,
we mostly keep
them in the museum,
but that was what you
did with the flow chart.
Despite making a
bad joke about it,
we're going to do
the same thing here.
We're going to do
the same thing here,
we're going to chart
out a little bit of what
should go into actually
making this thing work.
So here's a simple
flow chart that I'm

English: 
going to use to capture
what I just described.
And I'm going to,
again, I'm actually
going to do it the way they
used to do it, and draw
a rectangle with
rounded corners, that's
my starting point, and
then what did I say to do?
I said I need to
identify a variable,
I'm going to give it a
name, let's just call ANS,
for answer, and I
need to initialize it,
so I'm going to come
down, and in a square box,
I'm going to
initialize ANS to 0.
And now I want to
run through the loop.
What's the first
thing I do in a loop?
I test an end test.
So the flow chart says,
and the tradition was
to do this in a
diamond shape, I'm
going to check if
ANS times ANS-- oh,
which way did I want to
do this-- is less than
or equal to x.
Now that's a test.
There are two possibilities.

Korean: 
사용할 간단한 플로 차트가 있습니다. 
그리고 다시, 저는 사실 그들이 사용한 방법들을 하려고 합니다,  
둥근 모서리의 직사각형을 그리세요, 그것이 제 시작점 입니다, 
그리고 나서 제가 무엇을 말하려고 했죠? 
저는 변수를 식별해야 한다고 말했습니다, 저는 그것에 이름을 줄 것입니다, 
답을 위해 ANS 이라고 부릅시다, 그리고 저는 그것을 초기화해야 합니다, 
그리고 내려와서, 
네모 상자 안에서, ANS를 0으로 초기화 할 것입니다.
그리고 이제 저는 루프를 통해 런할 것입니다. 
제가 루프에서 하는 첫 번째 것은 무엇입니까? 
저는 마지막 테스트를 테스트합니다. 
플로 차트가 말하는 것은, 전통은 다이아몬드 모양으로 이것을 하는 것입니다, 
저는 ANS 곱하기 ANS 를 검사할 것입니다 – 오, 
제가 이것을 하려는 것이 어디 였죠 – 그것이 
x 보다 작거나 같은지를요. 
이제 이것이 테스트 입니다. 
두 가지 가능성이 있습니다.  

Korean: 
답이 yes이면, 저는 여전히 답을 찾을 것입니다, 
제가 무엇을 원하죠? 
저는 세는 것을 바꾸는 것 말고 어떤 것도 해서는 
안됩니다. 
그래서 저는 ANS로 가서 ANS 더하기 1이 되고, 
그것을 다시 합니다. 
결과적으로, 제가 이것을 옳게 하면 테스트는 – 그리고 
환상적으로 여기 공간에서 나오죠 – 이 경우에, 저는 
출력문으로 갈 것입니다, 그것은 
항상 부등변 사각형이죠, 그리고 ANS를 출력합니다. 
저는 멈추라고 말하는 박스를 그 아래에 그려야 했군요.
알겠죠? 
와우. 
그리고 제가 여기 한 것에 주목하세요. 
사실, 이것은 제가 그것을 합하는 방법을 시각화하는 유용한 도구입니다. 
왜냐하면 그것은 제가 루프가 어디 있는지 와, 저기 있군요, 
마지막 테스트를 볼 수 있게 하거든요,  
그것은 제가 변수를 초기화하고 해 가면서 
옳은 것을 하는지 검사하는 것을 확실히 해줍니다.
그리고 여러분이 시작하면, 

English: 
If the answer is yes, then I'm
still looking for the answer,
what do I want to do?
Well, I don't have
to do anything other
than change the counter.
So I'm going to go
to ANS is ANS plus 1,
and I'm going to do it again.
Eventually, if I've done
this right, that test is no--
and I wonderfully ran out of
room here-- in which case,
I'm going to go to a print
statement, which was always
done in a trapezoid,
and print out ANS.
I should have put a box
below it that says stop.
OK?
While.
And notice what I got here.
Actually, this is a useful
tool for visualizing
how I'm trying to
put it together,
because it lets me
see where the loop is,
right there, it lets
me see the end test,
it lets me make sure that I'm in
fact initializing the variable
and I'm checking the right
things as I go along.
And the idea of this flow chart
is, if you start, you know,

Korean: 
이 플로 차트의 생각은 여기 있는 작은 공입니다. 
그것을 구를 것이고, 대입문을 만들 것입니다, 그리고 나서, 여기에 따라, 
그것은 저기에 오리발 쌍과 같은 것이에요, 그것은 테스트를 합니다, 
그것은 그것을 ANS 더하기 1로 바꾸는 방법으로 공을 만듭니다, 
그리고 돌아 옵니다, 결과적으로 그것은 떨어질 것이고 
답을 출력합니다.  
제가 여러분에게 이 플로 차트를 보여주는 이유는, 
저는 곧 다른 예를 할 것인데 여러분에게 비교를 
보여주고 싶어서 입니다. 
지난 시간을 기억해 보세요, 우리는 짝수나 홀수를 출력하는 
간단한 코드를 썼습니다. 
사실 그것이 x이면, 짝수나 홀수 입니다. 
그래서 그것을 위한 플로 차트가 무엇과 같은지를 여러분에게 보여주겠습니다,  
왜냐하면 저는 여기 비교 핵심을 만들고 싶어요.
제가 그것에 대한 플로 차트를 하면, 
저는 다음과 같은 것을 합니다. 
그것은 여러분에게 다음을 상기시킵니다. 여기 테스트는, 
우리가 찾는 x를 가지고, 그것은 2로 인티져 나눗셈을 합니다,  
그것에 2를 곱하고, 우리는 그것이 
x와 같은지 확인합니다. 

English: 
a little ball bearing here, it's
going to roll down, setting up
an assignment statement,
and then, depending on here,
it's like there's a pair
of flippers in there,
it does the test, it
sets the ball this way
to change it to ANS plus
1, and comes back around,
eventually it's going to
drop through and print out
the answer.
The reason I'm going to
show you this flow chart,
I'm going to do one other
example in a second,
but I want to show
you a comparison.
Remember last time, we wrote
this simple piece of code
to print out even or odd.
If, you know, x, it was
in fact, even or odd.
So let me show you
what a flow chart
for that would look like,
because I want to make
a comparison point here.
If I were to do a flow chart for
that one, I'd do the following.
It reminds you,
that the test here
was, we took x if that's
what we were looking for,
it did integer division
by 2, multiplied it by 2,
and we check to see if
that was the same as x.

Korean: 
답이 yes 이면, 우리는 짝수를 출력합니다. 
답이 no 이면, 우리는 홀수를 출력합니다. 
그리고 계속 합니다. 
다시, 와우.
그러나 여기 중요한 핵심이 있습니다. 
지난 시간을 기억해 보세요. 저는 우리 코드 안에 다른 복잡성이 있다고 말했습니다, 
그리고 간단한 branching 프로그램을 제안했습니다, 
본질적으로, 그 프로그램을 
런하는데 걸리는 시간의 양은 명령문의 수에 달려 있습니다. 
왜냐하면 여러분은 기껏 해야 하나씩 실행하니까요.  
그것은 입력의 크기에 의존하지 않습니다. 
그리고 여러분은 거기서 그것을 볼 수 있어요.
시작하겠습니다, 이 길을 따라 계속 갈 것 입니다, 또는 저 길을 따라 계속 갈 것 입니다,  

English: 
If the answer is yes, then
we did a print of even.
If the answer was no,
we did a print of odd,
and we then carried on.
Again, while.
But there's an
important point here.
Remember last time,
I said that there's
different kinds of
complexity in our code,
and I suggested for simple
branching programs, the amount
of time it takes
to run that program
is, in essence, bounded by
the number of instructions,
because you only execute each
instruction at most once.
It didn't depend on
the size of the input.
And you can see that there.
I start off, either I take
this path and carry on,

English: 
or I take that path and carry
on, but each box, if you like,
gets touched exactly once.
On the other hand,
look at this one.
This depends now
on the size of x.
All right?
Because what am I going to do?
I'm going to come down and
say, is ANS squared less than
or equal to x?
If it is, I'm going to
go around, and execute
that statement, check it again,
and go around and execute that.
So I'm going to cycle
around that loop there
enough times to
get to the answer,
and that number of times is
going to depend on the input,
so as I change the
input, I'm going
to change the
complexity of the code.
Now this happens to be what we
would call a linear process,
because the number of
times I go around the loop
is directly related to
the size of the argument.
If I double the
argument, I'm going
to double the number of
times I go around the loop.
If I increase it
by five, I'm going
to increase by five the number
of times I go around the loop.
We'll see later on, there
are classes of computation
that are inherently
much more complex.
We hate them, because
they're costly,
but they're sometimes
inherently that way.

Korean: 
그러나 각 박스는 정확히 한 번 거칩니다.
그러나 각 박스는 정확히 한 번 거칩니다.
반면에, 이것을 보세요. 
이것은 이제 x의 크기에 의존합니다. 
그렇죠?  
제가 무엇을 하려고 하죠? 
저는 내려 가서 제곱 된 ANS가 
x 보다 작거나 같다고 말할 수 있습니까? 
그렇다면, 저는 가서, 그 식을 실행하고 
그것을 다시 확인할 것입니다, 그리고 가서 그것을 실행합니다. 
그래서 저는 답을 얻을 만한 충분한 시간 동안 루프를 순환합니다, 
그리고 시간의 수는 입력에 달려있습니다, 
그래서 제가 입력을 바꿀 때, 저는 코드의 
복잡성을 바꾸는 것입니다. 
이제, 이것은 선형 프로세스라는 것이 됩니다, 
왜냐하면 제가 루프를 도는 시간의 수는 인수의 크기와 
직접적으로 관련이 있기 때문입니다. 
제가 인수를 두 배로 늘리면, 루프를 도는 시간을 
두 배로 늘리게 됩니다. 
제가 인수를 다섯 배로 늘리면, 루프를 도는 시간을   
다섯 배로 늘리게 됩니다.
우리는 나중에, 선천적으로 더욱 복잡한 computation의  
종류들을 보게 될 것입니다. 
우리는 그것을 싫어합니다, 왜냐하면 그것은 비용이 많이 들거든요, 
그것들은 때때로 선천적으로 그런 방법입니다. 

Korean: 
그러나 여러분은 이 둘 사이에 비교를 볼 수 있습니다.
좋아요. 
이제, 그것을 했으니, 이 코드를 만들어 봅시다. 
네, 제 기계가 돌아오면, 해 봅시다. 
저는 이제 미리 가서 코드를 약간 쓸 것입니다, 
그리고 여기에 넣습니다, 여러분이 이 번에 이것을 더 좋게 볼 수 있길 바랍니다, 
이 부분을 uncomment 하겠습니다. 
좋아요. 
그래서, 기본적으로 코드의 상속화가 있죠, 
그렇죠? 
그것은 – 이것을 보세요, 제가 어디 있는지, 여기에 있어요 – 
저는 처음에 x의 어떤 값을 가집니다, ANS를 0으로 하고, 거기서 루프를 돕니다, 
이와 같은 테스트가 있어요, 
제곱된 ANS는 x 보다 작거나 같습니다, 
그렇다면, 루프와 일치하는 블록이 있어요, 
그리고 결과적으로 이 모든 것을 다 할 때, 
저는 ANS를 프린트 할 것입니다. 
네. 
좋아요, 여러분에게 사용할 한 가지 다른 도구를 보여주겠습니다. 

English: 
But you can see the
comparison between these two.
OK.
Now, having done that,
let's build this code.
Yeah, if my machine will
come back up, there we go.
So, I'm going to now
go ahead and write
a little piece of
code, and I put it here
and I hope you can actually
see these better this time,
let me uncomment that region.
All right.
So, there's basically an
encapsulation of that code,
right?
It says-- what, look
at this, where am I,
right here-- I've got some
value for x initially,
I'm going to set ANS
to 0, just like there,
and there's my loop, there's the
test, which is right like that,
is ANS squared less
than or equal to x,
if it is, there's the block
corresponding to the loop,
change ANS, and eventually when
I'm done with all this thing,
I'm just going to print ANS out.
OK.
All right, let me show you one
other tool that I want to use.

Korean: 
그것은, 제가 코드를 써왔는데,  
확인해 봐야겠군요. 
자, 저는 그냥 런할 수 있지만, 다른 유용한 것은, 
그 코드를 시뮬레이션하는 것입니다, 
저는 특히 이것들을 디버그 할 때 합니다.
그리고 저는 이것을 할 것입니다, 왜냐하면, 
구탁 교수가 저에게 알려준 대로, 학생들은 이것을 꺼려하는 것 같거든요. 
저는 이것이 충분히 남자다운 것이 아니라고 생각해요,  
시작할게요 그리고 손으로 해 보겠습니다, 여러분은 이것들을 런해야 합니다, 
그러나 그것은 들어 가는 중요한 도구 입니다, 
그러니 여기서 제가 해 보겠습니다. 
저는 훌륭한 일을 하고 있습니다. 
저는 아들이 둘 있는데 이제 18살과 20살 입니다. 
그들은 제가 세계에서 가장 좋은 직업을 가졌다고 생각하곤 했어요. 
왜냐하면 분필로 덮여 집에 갔으니까요. 
이제 그들은 여러분이 아마 생각할 수 있는 
다른 의견을 가질 것입니다. 
좋아요. 
코드를 시뮬레이션 하세요. 
제가 말하는 것은, 간단한 값들을 고르세요, 
그리고 무슨 일이 일어 나는지 보여 줄게요. 
그리고 이것은 유용합니다. 왜냐하면 이것은 제가 끝내는 것을 
가졌는지 확실히 하도록 하기 때문입니다. 
이것은 제가 옳은 업데이트 같은 것을 
확실히 하게 합니다.  
그런데 저는 이런 것을 합니다. 코드를 런하고 또한 
다양한 곳에서 출력문을 넣음으로써요. 그러나 

English: 
Which is, I've written
that piece of code,
I ought to check it.
Well, I could just run it,
but another useful thing to do
is, I'm, especially as I
want to debug these things,
is to simulate that code.
And I'm going to do this
because, as Professor
Guttag noticed to me, students
seem reluctant to do this.
I guess it's not
macho enough, John,
to just, you know, you know,
go off and do things by hand,
you ought to just run them,
but it's a valuable tool
to get into, so let
me do that here.
STUDENT: [UNINTELLIGIBLE]
PROFESSOR ERIC GRIMSON:
I'm doing such a great job.
I've got to say, when my, I've
got two sons, now aged eighteen
and twenty, they
used to think I had
the coolest job in
the world because I
came home covered in chalk.
Now they have a different
opinion that you can probably
figure out.
All right.
Simulate the code.
What I mean by that is,
pick a simple set of values,
and let's walk through
it to see what happens.
And this is useful
because it's going
to allow me to A, make sure
that I've got something that's
going to terminate,
it's going to let
me make sure that
in fact I'm doing
the right kinds of updates.
I could do this, by the
way, by running the code
and putting print statements
in various places as well,

Korean: 
손으로 시뮬레이션 하는 것은 중요해요, 시작해 보겠습니다. 
제가 여기서 무엇을 합니까? 
저는 변수 ANS가 필요해요, x도 필요하고 ANS 곱하기 ANS, 
ANS 곱하기 ANS도 필요해요. 
좋아요. 
이것들은 이 계산에 포함된 세 가지 것들 입니다. 
그리고 저는 합리적으로 간단한 것을 고를게요. 
ANS는 0에서 시작합니다. 
저는 x를 만드는데, 제 생각에, 저기 16이 될 거 같아요. 
그래서 루프가 무엇을 말하죠? 
저는 제 플로 차트를 볼 수도 있고 
코드를 볼 수 도 있습니다. 
제가 플로 차트를 보면, 저는 이 포인트에 있습니다. 
제곱된 ANS를 보세요. 
이것이 작거나 같은지 – 미안해요, 먼저, 
제곱된 ANS는 0입니다, 이것은 x 보다 작거나 같아요, 
네. 그래서 제가 무엇을 하죠? 
ANS를 바꾸세요. 
X는 바뀌지 않습니다. 
테스트로 돌아 갑시다 
제곱된 ANS가 무엇이죠? 
그것은 1입니다. 
그것이 16 보다 작거나 같습니까? 
물론이죠. 
다시 루프를 돌리세요. 
ANS는 2가 됩니다. 
X는 여전히 16 이고요. 
제곱된 ANS는 4입니다. 
그것이 16 보다 작거나 같습니까? 
네. 
제가 x를 500으로 고르지 않아서 기쁘지 않나요? 

English: 
but the hand
simulation is valuable,
so let me just start it.
What do I have here?
I need the variable,
ANS, I need x,
and I need ANS times
ANS, ANS times ANS.
Right.
Those are the three
things that are
involved in this
computation. and I pick
something reasonably simple.
The ANS starts at 0.
I set up x, I think,
to be 16 there.
So what does the loop say?
I can either look
at my flow chart,
or I can look at the code.
If I look at the flow chart,
it says, I'm at this point.
Look at ANS squared.
Is it less than or
equal to-- sorry,
first of all, ANS squared is 0,
is it less than or equal to x,
yes.
So what do I do?
Change ANS.
X doesn't change.
Back around to the test.
What's ANS squared?
It's 1.
Is it less than or equal to 16?
Sure.
Run the loop again.
ANS becomes 2.
X stays 16.
ANS squared is 4.
Is that less than
or equal to 16?
Yes.
Aren't you glad I didn't
pick x equals 500?

English: 
All right.
ANS goes up by 0.
ANS squared is nine.
Still less than or equal to 16.
ANS goes to 4.
X stays the same.
4 squared is 16.
Is 16 less than or equal to 16?
Yes.
So ANS goes to five.
ANS squared becomes 25.
Ah!
That is now no longer true
here, so I print out 5.
Right.
Sure.
Square root of 16 is 5.
It's Bush economics.
OK?
I know.
I'm not supposed to make
bad jokes like that.
What happened?
Yeah.
STUDENT: It doesn't
stop at the right place.
PROFESSOR ERIC
GRIMSON: It doesn't
stop at the right place.
Thank you.
Exactly.
Right?
My bug here is right there.
Ah, let me find my cursor.
I probably want that.

Korean: 
좋아요. 
ANS는 0에서 시작합니다. 
제곱된 ANS는 9입니다. 
여전히 16 보다 작거나 같습니다. 
ANS는 4가 됩니다. 
X는 여전히 같습니다. 
4를 제곱하면 16입니다. 
16은 16 보다 작거나 같습니까? 
네. 
그래서 ANS는 5가 됩니다. 
ANS 제곱은 25 입니다. 
아! 
이것은 여기서 더 이상 옳지 않습니다, 그래서 저는 5를 출력합니다.  
네. 
물론이죠. 
16의 제곱근은 5입니다. 
부시 경제학이네요. 
네? 
저는 알아요. 
제가 이와 같은 나쁜 유머를 해서는 안 된다는 것을요. 
무슨 일이 일어났죠? 
네. 
그것은 올바른 곳에서 멈추지 않습니다. 
그것은 올바른 곳에서 
멈추지 않았어요. 
고마워요. 
정확해요. 
그렇죠? 
여기 제 버그는 여기 있습니다. 
아, 제 커서를 찾을게요. 

Korean: 
저는 아마 그것을 원합니다. 
네? 
저는 작거나 같은 것 보다는 작은 것을 원해요. 
이것은 나타나는 쉬운 버그에요. 
그러나 상상해 보세요, 여러분이 테스트를 하지 않으면 여러분은 
말이 안 되는 답을 얻을 거에요. 
그리고 사실, 우리가 미리 가서 이것을 런 해서, 희망적으로 우리는 – 
웁스, 미안해요, 저는 이것을 빨리 바꿀게요, 
저는 여전히 아래에서 uncomment 된 것을 가지고 있군요, 
네, 거기 있어요, 저는 아직 우리가 이것이 필요하지 않다고 생각해요, 
좋아요, 우리는 이것을 comment 할 것입니다. 
좋아요. 
그래서, 
제가 무엇을 했죠? 
이것은 간단한 예입니다, 저는 동의해요, 그러나 제가 한 것에 주목하세요. 
그것은 제가 강조하도록 합니다, 코드가 옳은 것을 하고 있나요? 
저는 여기 에러를 찾았습니다, 저는 다른 테스트 세트에서 런하고 
프린트를 사용함으로써 에러를 찾을 수도 있었어요, 
이것을 하는 다른 방법은, 적어도 간단한 예제에서 
그것을 시뮬레이션 하는 이 생각은 여러분이 중요한 
질문들을 확인 하도록 합니다. 
그리고 사실, 이 코드에 대해 

English: 
Right?
I want less than, rather
than less than or equal to.
This is an easy bug
to come up with.
But imagine, if you
don't do the test,
you're going to get answers
that don't make any sense.
And in fact, if we just
go ahead and run this now,
hopefully we get
out-- oops, sorry,
I'm going to have to
change this quickly,
I still have some
things uncommented
at the bottom, yeah,
there they are,
I don't think we
need that yet, all
right, we will
comment those out.
OK.
So.
Why did I do it?
It's a simple example, I agree,
but notice what I just did.
It allowed me to highlight, is
the code doing the right thing?
I spotted an error here,
I could have spotted it
by running it on different test
sets, and using prints things,
another way of doing
it, but this idea
of at least simulating
it on simple examples
lets you check a couple
of important questions.
And in fact, now let me
ask those two questions

Korean: 
두 질문을 해 봅시다. 
첫 번째 질문은, 어떤 인티져 값을 위해 – 
우리는 인티져라고 가정할 것입니다 – 어떤 x 값을 위해 
이 코드가 끝나나요? 
그리고 두 번째 질문은, 어떤 x 값을 위해 그것이 
저에게 옳은 답을 줍니까? 
좋아요, 첫 번째 질문입니다. 
어떤 x의 값이 그것을 끝내지요? 
다시, x가 인티져라고 가정합시다. 
자, 해 봅시다. 
X가 양수라고 가정해보세요. 
그것이 끝납니까? 
물론입니다. 
그렇죠? 
왜냐하면 ANS가 0에서 시작하기 때문에, 
제곱된 ANS는 0입니다, 그리고 루프를 통해 매번, ANS는 증가할 것입니다. 
그것이 의미하는 것은, 어떤 점에서, 어떤 유한한 단계의 수에서, 
제곱된 ANS는 x가 양수이면 x 보다 커져야 합니다. 
그래서 양수 인티져를 위해, 그것은 끝납니다. 
그리고 그것은 아마, 저는 우리가 추론할 수 있다고 생각해요, 여기서 
옳은 답을 리턴 해 줍니다. 
좋아요. 
X가 음수입니다. 
X는 -16이에요. 

English: 
about this piece of code.
First question is, for
what values of integers--
we're going to assume integers--
but for what values of x
does this code terminate?
And the second question
is, for what values of x
does it give me back
the right answer?
All right, first question.
What values of x
does it terminate?
Again, assume x is an integer.
Well, break it down into pieces.
Suppose x is positive.
Does it terminate?
Sure.
All right?
Because ANS starts out
as 0, so ANS squared is
0, and each time through
the loop, ANS is increasing.
That means, at some point, in
some finite number of steps,
ANS squared has got to get
bigger than x if x is positive.
So for positive
integers, it terminates.
And it probably, I
think we can deduce,
returns the right answer here.
Right.
X is negative.
X is -16.

English: 
Does this code terminate?
Boy, I feel like
Arnold Schwarzenegger.
Does this terminate?
Somebody.
STUDENT: [UNINTELLIGIBLE]
PROFESSOR ERIC
GRIMSON: Ah, thank you,
so it does terminate, right?
You're sitting too far back, let
me try-- oh, too far!-- Sorry.
Come get me one later
if you can't find it.
Yes, it stops at the
first step, right?
Let's look at it.
It says, if answer, sorry,
imagine x is -16, ANS is 0,
is 0 less than -16, no.
So what does it do?
It prints out 0.
Ah!
So that now answers my second
question, it does terminate,
but does it give me
the right answer?
No.
Right?
It gives me an
answer, and imagine
I'm using this somewhere else,
you know, it's going to go off
and say, gee, the
square root of -16 is 0.
Well, it really should be a,
you know, an imaginary number,
but this is not a valuable
thing to have come back.

Korean: 
이 코드가 끝납니까? 
제가 아놀드 슈워제네거처럼 느껴지네요. 
이것이 끝납니까? 
누가 말해 보세요. 
아, 고마워요, 
이것이 끝납니다, 그렇죠? 
여러분은 너무 멀리 뒤에 앉아 있어요, 해 봅시다 – 
오, 너무 멀어요! – 미안해요. 
여러분이 찾을 수 없으면 저에게 나중에 오세요. 
네, 이것은 첫 번째 단계에서 끝납니다, 그렇죠? 
이것을 봅시다. 
답변하면, 그것은, 미안해요, x가 16이고, ANS가 0이라고 상상해 보세요, 
-16 보다 작나요, 아닙니다. 
그래서 그것이 무엇을 하죠? 
0을 출력합니다. 
아! 
그래서 그것은 지금 제 두 번째 질문에 답하는 군요, 그것은 끝납니다, 
그러나 그것은 저에게 옳은 답을 주나요? 
아닙니다. 
그렇죠? 
그것은 저에게 답을 줍니다, 그리고 제가 이것을 어디에서 사용한다고 상상해 보세요. 
그것은 시작하고 
-16의 제곱근이 0이라고 말할 것입니다. 
자, 이것은 정말 상상의 수에요, 
그러나 이것은 돌아 갈 귀중한 것이 아닙니다. 

English: 
So that's the second thing
I've just highlighted here,
is that I now have the
ability to check whether it
does the right thing.
And those are two
things that you'd
like to do with every
looping construct you write:
you'd like to be able to assure
yourself that they will always
terminate, and then the
second thing you'd like to do,
is to assure yourself
that it does give you back
a reasonable answer.
We started to talk about
ways to do the former.
It's looking at the end test.
It's looking at the
kinds of conditions
you're going to put in.
For the latter, this
is a place where
running test cases would do a
good job of helping with that.
Nonetheless, having done that,
let's look at a better way
to write this.
Which is right here, it is
also, I think, on your sheet,
I'm going to uncomment that,
and comment this one out, yeah.
All right?
So let's look at this
code for a second.
Notice what this does.
Certainly the heart
of it, right in here,
is still the same thing.

Korean: 
그래서 제가 여기서 강조하는 두 번째 것은, 
제가 지금 그것이 옳은지 아닌지 확인할 능력을 
가지고 있다는 것입니다. 
그리고 이것들은 여러분이 쓰는 모든 루프 구조들로 하고 
싶은 두 가지 입니다: 여러분은 여러분이 그것이 항상 끝날 것이라는 것을   
확신하고 싶습니다, 그리고 나서 
여러분이 하고 싶은 두 번째 것은 스스로 그것이 여러분에게 
합리적인 답을 돌려 준다는 것을 확신하는 것입니다.
우리는 전자를 하는 방법에 대해 이야기를 시작했습니다. 
그것은 마지막 테스트를 봅니다.  
그것은 여러분이 입력한 조건문들을 
봅니다. 
후자를 위해, 이것은 테스트 경우를 런하는 것이 그것을 
돕는 좋은 일이라는 곳입니다. 
그렇지만, 그것을 다 했으니, 이것을 쓰는 
더 나은 방법을 봅시다. 
그것은 여기 있는데, 이것은 또한, 제 생각에, 여러분 시트에 있어요, 
저는 그것을 uncomment 하려고 합니다, 그리고 이것을 comment 할 것입니다, 네. 
알겠죠? 
그래서 곧 이 코드를 보겠습니다. 
이것이 무엇을 하는지 주목하세요. 
확실히 여기 있는, 이것의 핵심은 
여전히 같은 것입니다. 

English: 
But notice what this does.
The first thing it does
is, it says, let's check
and make sure x is greater
than or equal to 0.
If it isn't, notice
what's going to happen.
None of that block is
going to get executed,
and it's going to come
down here and print out
a useful piece of
information, which says, hey,
you gave me a negative number.
I don't know how to do this.
If it is, in fact, positive,
then we're going to go in here,
but now notice what
we're doing here.
There is the basic thing
we did before, right?
We're checking the end
test and incrementing,
actually I was going to, I
commented that out for a reason
you'll see in a second,
but I, normally I
would keep this on, which
would let me, at each step,
see what it's doing.
If I ran this, it would
print out each step.
Which is helping me
make sure that it's
incrementing the right way.
OK, once it gets to the end of
that, what's it going to do?
It's going to come
down here and, oh.
What's that doing?
Well, I cheated when I started.
I said, somebody's giving
me a perfect square,
I'm looking for the
square root of it.
But suppose I gave this thing
15, and asked it to run.
It'd still give me an answer.
It just would not be the
answer I'm looking for.

Korean: 
그러나 이것이 무엇을 하는지 주목하세요. 
그것이 하는 첫 번째 것은, 그것은 검사하고 
x가 0 보다 크거나 같은지 확인하라고 말합니다. 
그렇지 않으면, 무엇이 일어 나는지 주목하세요. 
그 블록의 아무 것도 실행 되지 않습니다, 
그러면 그것은 이 아래로 내려 와서 유용한 정보를 프린트 합니다, 
그것은, 이봐, 당신이 나에게 음수를 줬어 라고 말합니다. 
저는 이것을 어떻게 하는지 모르겠어요. 
사실, 그것이 양수이면, 우리는 여기로 갈 것이지만, 
이제 여기서 무슨 일이 일어 나는지 주목하세요. 
우리가 전에 했던 기본적인 것 입니다, 그렇죠? 
우리는 마지막 테스트를 검사하고 증가할 것입니다, 
사실 저는 그것을 comment 하려고 했어요 여러분이 곧 볼 것이라는 이유로요. 
그러나 저는, 보통 이것을 가지고 있습니다, 
각 단계에서 그것은 무슨 일이 일어 나는지 볼 수 있어서요. 
제가 이것을 런하면, 그것은 각 단계를 프린트합니다. 
그것은 제가 그것이 옳게 증가한다는 것을 
확신하게 합니다.  
좋아요, 이것이 끝으로 가면, 그것은 무엇을 합니까? 
그것은 여기 아래로 내려옵니다, 오. 
그것이 무엇을 하죠? 
자, 저는 시작 할 때 속임수를 썼어요. 
저는 누군가가 저에게 완벽한 제곱을 주었다고 말했습니다. 
저는 그것의 제곱근을 찾고 있어요. 
그러나 제가 이것에 15를 주고 런하라고 요청했다고 가정해 보세요. 
그것은 여전히 저에게 답을 줍니다. 
그것은 제가 찾는 답이 아니죠. 

English: 
So now, in this case, this code
is going to, when we get here,
check, and if you haven't
seen that strange thing there,
that exclamation point in
computer-ese called a bang,
it says if ANS star ANS is
not equal to x, all right?
What's that say, it
says, I've already
gotten to the end
of the loop, I'm now
past where I wanted
to be, and I'm
going to check to make sure
that, in fact, this really
is a perfect square.
If it isn't, print
out something says,
ah, you gave me something
that wasn't a perfect square.
And only if that is true, am I
going to print out the answer.
It's the same computation.
But this is a nice
way of writing it,
often called
defensive programming.
And I think we have lots of
variations on it-- I don't
know about John, what
your favorite is,
for the definition of defensive
programming-- for me it says,
make sure that I'm going
through all possible paths
through the code, make sure
I'm printing out, or returning

Korean: 
그래서 이제, 이 경우에, 우리가 여기 갔을 때, 이 코드는, 
여러분이 거기서 이상한 것을 보지 않았다면, 
그 감탄사는 컴퓨터에서 bang이라는 것이에요,  
그것은 ANS 별 ANS 가 x와 같지 않은지 말해 줍니다, 알겠죠? 
그것이 말하는 것은, 제가 이미 루프의 마지막을 갔다는 것이에요, 
저는 이제 제가 원하던 곳을 지났어요,
그리고 저는 사실, 이것이 정말 완벽한 제곱인지 
확인하려고 해요. 
그렇지 않으면, 무엇을 프린트 하는데, 아, 여러분은 
저에게 완벽한 제곱이 아닌 것을 주었어요. 
그리고 그것이 옳은 경우에만, 저는 답을 프린트 할 것입니다.  
그것은 같은 계산입니다. 
그러나 이것은 그것을 쓰는 
좋은 방법이죠, 종종 방어적 프로그래밍이라고 합니다. 
그리고 저는 우리가 그것에 많은 변화들을 가지고 있다고 생각해요 – 저는 존에 대해 모릅니다, 
여러분이 가장 좋아하는 것이 무엇인지 몰라요, 
방어적 프로그래밍의 정의를 위해서요 – 저에게 그것은 
제가 그 코드를 통해 모든 가능한 경로들을 살펴보는 것을 확실히 하라고 말합니다. 

English: 
if you like, useful information
for each style, sorry,
for each path through
the code, make sure
that for all
possible inputs there
is a path through
the code, or a way
to get through the code,
that does not cause an error
or infinite loop.
What else would you add, John?
PROFESSOR JOHN
GUTTAG: Well, we'll
come back to this
later in the term,
and talk in some detail
about particular techniques.
The basic idea of
defensive programming
is, to assume that A, if you're
getting inputs from a user,
they won't necessarily give
you the input you've asked for,
so if you ask for
a positive number,
don't count on them
giving you one, and B,
if you're using a piece
of a program written
by a programmer
who is not perfect,
perhaps yourself, there could
be mistakes in that program,
and so you write your program
under the assumption that,
not only might the
user make a mistake,
other parts of your program
might make a mistake,
and you just put in
lots of different tests

Korean: 
제가 프린트 하는 것 또는 각 스타일에, 
미안해요, 코드를 통한 각 경로에 유용한 정보를 리턴하는 것을 확실히 하라고 합니다. 
그 코드를 통한 경로에 있는 모든 가능한 입력들 도는 
코드를 살펴 보는 방법을 확실히 하라고 합니다. 
그것은 에러나 무한 루프를 유발하지 않습니다. 
당신이 더하고 싶은 게 있나요, 존? 
우리는 나중에 이것으로 다시 돌아 올 것입니다, 
그리고 특정한 기술들에 대해 자세한 것을 이야기 할 것입니다.
그리고 특정한 기술들에 대해 자세한 것을 이야기 할 것입니다.
방어적 프로그래밍의 기본 생각은 다음을 가정하는 것입니다, 
A, 여러분이 사용자로부터 입력을 얻었다면, 
그들은 필수적으로 여러분에게 여러분이 요청한 입력을 주지 않을 것이에요, 
그래서 여러분이 양수를 요청하면, 여러분에게 준 것에 의존하지 마세요, B, 
여러분이 완벽하지 않은 프로그래머에 의해 쓰여진 코드를 사용한다면, 
아마 여러분 자신이겠죠, 
그 프로그램에 실수들이 있을 것이에요, 그러면 여러분은 그 가정 하에서 여러분의 쓰겠죠, 
사용자가 실수를 했을 뿐만 아니라, 
여러분 프로그램의 다른 부분들도 실수를 합니다, 
그리고 여러분은 많은 테스트를 합니다, 

Korean: 
여러분이 잘 못된 것을 잡겠다는 가정 하에서요, 
그리고 틀리고 여러분은 그것을 모릅니다. 
그리고 우리는 학기 나중에 많은 다른 기술들에 대해 이야기 할 것이지만, 
마음 속에 가져야 할 주요한 것은  
사람들이 바보라는 일반적인 원칙입니다. 
그리고 실수를 할 것입니다. 
그러므로, 여러분은 이 실수가 만들어 졌을 때 
재앙이 일어나지 않도록 프로그램을 짜세요. 
좋아요. 
존이 말한 대로, 우리는 이것으로 돌아 올 것입니다. 
그러나 기본적으로 목표는 여기 있어요. 
그리고 여러분은 제가 어리석은 프로그래머를 말했을 때 손을 들어올리는 걸 보았죠? 
저는 확실히 이 문제가 있는 코드를 씁니다, 
저는 이 문제를 가지는 제 코드를 쓰려고 했습니다, 그리고 우리에게 좋은, 
그래요, 좋은 위생, 제가 위생이라는 단어를 여기서 다시 쓰는 군요, 
방어적인 코드를 쓰는 습관에 좋아요, 
그것은 여러분이 해야 하는 것들의 컬렉션의 일부에요, 
그것은 좋은 것입니다. 
저는 특히 그것을 강조하고 싶어요 왜냐하면, 저는 
여러분이 모두 이 단계로 갈 것이라는 것을 알기 때문이에요;  
몇 시간 안에 문제 세트 마감 시간이 되겠군요, 여러분은 여전히 코드를 쓰고 있을 겁니다, 
시간을 "낭비" 하고 싶지 않겠죠, 

English: 
under the assumption
that you'd rather catch
that something has gone wrong,
then have it go wrong
and not know it.
And we'll talk later in
the term about dozens
of different tricks, but the
main thing to keep in mind
is the general principle
that people are dumb.
And will make mistakes.
And therefore, you
write your programs
so that catastrophes don't occur
when those mistakes are made.
PROFESSOR ERIC GRIMSON: Good.
As John said, we're
going to come back to it.
But that's what,
basically the goal here.
And you saw me put my hands up
when I said stupid programmer?
I've certainly written
code that has this problem,
I've tried to use my own
code that has this problem,
and good to us,
right, good hygiene,
I'm going to use
that word again here,
of getting into the habit
of writing defensive code up
front, it's part of that
collection of things
that you ought to do,
is a great thing to do.
I stress it in
particular because, I
know you're all going
to get into this stage;
you've got a problem set
due in a couple of hours,
you're still writing the code,
you don't want to waste time,
and I'm going to use quotes
on "waste time", doing those

English: 
extra things to do the
defensive programming,
you just want to get
the darn thing done.
It's a bad habit to get into,
because when you come back
to it, it may haunt you
later on down the road.
So really get into
that notion of trying
to be defensive as you program.
OK.
The other thing I
want to say here,
is that this style of
program we just wrote,
is actually a very common one.
And we're going to give it
a nice little name, often
referred to as
exhaustive enumeration.
What does that mean?
It says, I'm literally walking
through all possible values
of some parameter, some
element of the computation,
testing everything until
I find the right answer.
All right, so it's,
you know, again, I
can even write that
down, essentially saying,

Korean: 
방어적인 프로그래밍을 하기 위한 잔여 일들을 하려면, 
여러분은 이 젠장 맞을 것을 하고 싶을 거에요.
그것으로 들어가는 것은 나쁜 습관입니다. 왜냐하면 여러분이 그것으로 돌아 왔을 때, 
그것은 여러분을 나중에도 계속 괴롭혀 문제가 되기 때문입니다. 
그래서 여러분이 프로그램을 할 때 방어적이 되려는 개념으로 
정말 들어가세요. 
좋아요. 
제가 여기서 말하려는 다른 것은, 
우리가 쓴 프로그램의 이 스타일이 사실 매우 일반적인 것이라는 겁니다. 
그리고 우리는 그것에 좋은 작은 이름을 줄 것이에요, 
종종 철저한 계산으로 불리죠.  
그것이 무엇을 의미 할까요? 
저는 정말로 어떤 인자, 계산의 어떤 요소의 
모든 가능한 값들을 살펴 볼 것입니다. 
제가 옳은 답을 찾을 때까지 모든 것을 테스트 할 것이에요. 
좋아요, 다시, 저는 그것을 쓸 수 있습니다, 
본질적으로 말해서, 모든 합리적인 값들을 시도하세요 

Korean: 
여러분이 답을 찾을 때 까지요. 
그리고 여러분은 말할지도 모릅니다, 잠시만요, 
그것이 정말 비쌀 것인가요? 
그 답은, 네, 제 생각엔, 여러분이 찾을 바란다면, 
구글의 모든 페이지를 하나씩 살펴 보세요, 
아마, 시간이 좀 걸릴 거에요. 
그러나 이것이 그것을 하는 좋은 방법이 되는 
정말 많은 계산들이 있어요. 
여러분은 철저하게 그것들을 살펴보길 원합니다.  
그리고 그것에 대한 감각을 주기 위해, 
여러분에게 예를 보여 줄게요. 
저는 이것을 바꾸고 싶어요, 알겠죠? 
좋은 큰 수에요. 
컴퓨터는 요즘 매우 빠릅니다. 
저는 이것을 더 크게 할 수도 있어요, 
그것은 꽤 빠르게 할 것입니다, 그래서 그것은 이것을 하는데 정말 빠릅니다. 
그것은 철저한 계산이 나쁜 생각이라는 것을 의미하지 않아요, 
그것은 종종 사용하기 좋은 생각이에요. 
그래서 우리는 제곱근을 찾는 모든 인티져들을 살펴 보는 
생각의 예를 봤어요. 
다른 예들을 봅시다, 우리가 그것을 할 수 있는  
다른 방법을 보기 위해서요.
좋아요. 
특히, 여기로 가 봅시다, 그리고 
두 번째 예를 보여주겠습니다.  

English: 
try all reasonable values
until you find the solution.
And you might say,
well, wait a minute,
isn't that going to
be really expensive?
And the answer is, yeah, I
guess, if you want to search,
you know, all the pages
on Google, one by one,
yes, probably, it's
going to take a while.
But there are an awful lot of
computations for which this
is the right way to do it.
You just want to exhaustively
go through things.
And just to give
you a sense of that,
let me show you an example.
I'm going to change
this, all right?
Nice big number.
You know, computers
are fast these days.
I can make this
even bigger, it's
going to do it fairly
quickly, so it really
is quick to do this.
It doesn't mean that exhaustive
enumeration is a bad idea,
it is often the
right idea to use.
So we've seen one
example of this,
this idea of walking through
all the integers looking
for the square root.
Let's look at some
other examples,
in order to try and see other
ways in which we could do it.
OK.
In particular, let's
go over to here,
and let me show you
a second example.

Korean: 
그리고 그것을 comment 하겠습니다. 
여기 제가 풀려고 하는 다른 문제가 있습니다. 
제가 어떤 정수의 모든 약수를 구하길 원한다고 생각해 보세요, 
저는 모든 약수들이 균등하게 그것으로 들어가는 것을 
알아 내길 원합니다. 
다시, 같은 추론을 해 보면, 같은 값 x가 주어 졌을 때, 
저는 여기서 작은 것을 골랐어요, 이것을 하는 
쉬운 방법이 뭐죠?
1부터 시작해 봅시다. 
그것은 제가 바꾸고 검사하려는 변수입니다. 
그것이 균등하게 x로 나눕니까? 
그렇다면, 그것을 출력하세요. 
다음 것으로 가 봅시다, 그것을 출력하세요. 
다시, 저는 여기서 같은 것을 할 수 있습니다. 여러분은 그것을 볼 수 있어요, 
사실, 그것이 옳은 것을 하는지 확인하기 위해 그것을 런해 봅시다, 
알겠죠? 사실, 
제가 코드로 돌아 오면, 저는 여기서 
무엇을 하기로 결심했죠? 
저는 I의 초기화부터 시작합니다. 
제 첫 번째 단계 입니다, 1과 같을 때, 
제가 검사할 작은 루프를 살펴 볼 것입니다, -- 먼저, I가 x 보다 작은 한, 
제 마지막 테스트가 있습니다, 

English: 
And let me comment that out.
Here's another problem
that I'd like to solve.
Suppose I want to find all
the divisors of some integer,
I want to figure out
what all the divisors are
that go evenly into it.
Again, same kind of reasoning
says, given some value
x, I happened to pick a small
one here, what's an easy way
to do this?
Well, let's just start at one.
That's my variable I'm
going to change and check.
Does it divide evenly into x?
If it does, print it out.
Move on to the next
one, print it out.
So again, I can do the
same kind of thing here,
you can see that,
in fact, let's just
run it to make sure it
does the right thing, OK?
In fact, if I go
back to the code,
what did I decide to do here?
I say, starting with
an initialization of I,
there's my first
step, as equal to 1,
I'm going to walk
through a little loop
where I check, as
long-- first of all,
as long as I is less than
x, so there's my end test,

English: 
I'm going to do something.
And in this case,
the something is,
I'm going to look to see
if I divides x evenly.
So I'll remind you
of that amp-- sorry,
that percent sign there,
that says if x divided by I
has a 0 remainder, because this
gives me back the remainder,
if that's equal to 0,
print something out.
And there's my nice increment.
Simple little piece of code.
Notice again, exactly
the same form:
I picked the thing
I wanted to vary,
I initialized it
outside the loop,
I have a test to
see when I'm done,
and then I've got a
set of instructions
I'm doing every time
inside the loop.
In this case, it's doing
the check on the remainder
and printing them out.
And when I'm done
with the whole thing,
before I end the
increment of the variable,
you know, when I'm done, I'm
just not returning anything
out.
OK.
So now you've seen
two simple examples.
Let me generalize this.
In this case, my incrementer
was just adding 1 to an integer,
it's a pretty
straightforward thing to do.
But you can imagine
thinking about this a little
differently.
If I somehow had a collection,
an ordered collection of all

Korean: 
저는 그것을 할 것입니다. 
그리고 이 경우에, 그것은, 저는 I 가 x로 
균등하게 나눠지는지 살펴 볼 것이에요. 
그래서 저는 여러분에게 그 amp를 상기 시키고 싶군요 – 미안해요, 저기 퍼센트 기호입니다, 
그것은 I로 나눠진 x가 나머지를 가지는지 말합니다, 왜냐하면 
이것은 저에게 나머지를 돌려줍니다, 그것이 
0과 같으면, 출력하세요. 
그리고 좋은 증가가 있습니다. 
간단한 작은 코드입니다. 
다시 주목하세요, 정확히 같은 형태에요: 저는 제가 
변화를 주고 싶은 것을 고르고, 그것을 루프 밖에서 초기화 했습니다,  
저는 제가 했을 때를 볼 테스트를 가집니다, 
그리고 나서 저는 루프 안에서 매번 하는 명령문들 세트를 가집니다 
이 경우에, 그것은 나머지를 체크하고 
출력합니다.
그리고 전체 일을 다 했을 때,  
제가 변수 증가를 끝내기 전에, 제가 다 했을 때, 
저는 어떤 것도 리턴하지 않습니다. 
네.
이제 여러분은 두 간단한 예를 보았습니다.
이것을 일반화해 봅시다.
이 경우에, 저의 증가는 어떤 정수에 1을 더하는 것입니다, 
그것은 매우 간단한 일이에요.
그러나 여러분은 이것에 대해 약간 다르게 
생각하는 것을 상상할 수 있습니다. 
제가 왠지 컬렉션을 가지고 있으면, 

English: 
the integers, from
1 to 10, I could
imagine doing the same thing,
where now what I'm doing
is, I'm starting with the first
element of that collection,
doing something, going
to the next element,
doing something, going to the
next element, doing something,
I'm just walking through
the sequence of elements.
Right?
And I haven't said yet, how
do I get that collection,
but you could
certainly conceptualize
that, if I had that collection,
that would be nice thing to do.
That is a more common pattern.
That is basically saying,
given some collection of data,
I want to have again a
looping mechanism, where
now my process is, walk
through this, the collection,
one element at a time.
And for that, we have
a particular construct,
called a FOR loop.
It's going to do
exactly that for us.
It's going to be more
general than this,
and we're going to
come back to that,
in fact, Professor Guttag's
going to pick this up
in a couple of lectures,
but we can talk right now
about the basic form.
The form of a FOR
loop says, FOR,
and I'm going to put
little angle braces in here
again, to say,
for some variable,

Korean: 
1부터 10까지, 모든 정수의 순서 대로의 컬렉션을요, 저는 같은 것을 하는 걸 상상 할 수 있어요. 
지금 제가 하는 것은, 저는 그 컬렉션의 첫 번째 요소에서 시작하고 있어요, 
무언가를 하고, 다음 요소로 가서, 
무언가를 하고, 다음 요소로 가고, 
무언가를 합니다. 저는 단지 
요소들의 순서를 살펴 보고 있어요. 
알겠죠? 
그리고 저는 아직 제가 어떻게 그 컬렉션을 얻을 수 있는지 말하지 않았어요,  
그러나 여러분은 그것을 확실히 개념화 할 수 있어요, 제가 그 컬렉션을 가지면, 
그것은 하기 좋은 일이 됩니다. 
그것은 더욱 일반적인 패턴이죠. 
그것은 기본적으로, 어떤 데이터의 컬렉션이 주어 졌을 때, 
저는 다시 루프 매커니즘을 하고 싶어요, 제 프로세스는 
지금, 시간에서 하나의 요소, 
이 컬렉션을 살펴 보세요.
그리고 그것을 위해, 우리는 FOR 루프라는 
특정한 구조를 가집니다. 
그것은 정확히 우리가 하는 것입니다. 
그것은 이것 보다 더욱 일반적인 것이고 우리는 그것으로 돌아 올 것입니다, 
사실, 구탁 교수는 몇 강의에서 
이것을 골랐지만, 
우리는 지금 기본 형태에 대해 이야기 할 수 있어요.
FOR 루프의 형태는, FOR, 그리고 여기 
작은 괄호를 다시 둘 것입니다, 제가 그것에 이르고 싶은 이름과 같은 

English: 
like a name I want to get
to it, in some collection,
and then I have a block of code.
And what it's saying
semantically is,
using that variable
as my placeholder,
have it walk through
this collection,
starting at the first thing,
execute that code, then
the next thing, execute
that code, and so on.
One of the advantages
of this is,
that I don't have to
worry about explicitly
updating my variable.
That happens for
me automatically.
And that's very
nice, because this
allows me to be sure that my
FOR loop is going to terminate.
And because, as long as
this collection is finite,
this thing is just
going to walk through.
All right?
So, if I show you,
for example, I'm
going to comment this one
out in the usual manner,

Korean: 
어떤 변수를 위해, 어떤 컬렉션에서, 
그리고 나서 저는 코드의 블록을 가집니다. 
그리고 이것이 의미적으로 말하는 것은, 제 플레이스 홀더로써 그 변수를 사용하는 것은
이 컬렉션을 살펴 보도록 합니다, 
첫 번째부터 시작해서, 그 코드를 실행하세요, 
그리고 다음 것을 하고, 코드를 실행하세요, 그리고 계속합니다. 
이것의 이점 중 하나는, 저는 제 변수를 
명쾌하게 업데이트 하는 것에 대해 걱정하지 않아도 된다는 것입니다. 
그것은 저에게 자동적으로 일어납니다. 
그리고 그것은 매우 좋아요, 왜냐하면 
이것은 제가 제 FOR 루프가 끝날 것인지 확실히 하게 해 주거든요. 
그리고 왜냐하면, 이 컬렉션이 유한한 한, 
이것은 단지 살펴 볼 것입니다. 
그렇죠? 
그래서, 예를 들어, 제가 여러분에게 보여 주면, 저는 평범한 방법으로 이것을 comment 할 것입니다, 
그리고 그것을 uncomment 하는 것을 봅시다, 

English: 
and let's look at
uncommenting that, there
is the same piece of code.
Now, I slung something by
you, or snuck something
by you, which is,
I hadn't said how
to generate the set of
integers from 1 to 10.
So, range is a built-in
Python function.
I'm going to come back
to it in a second.
For now, just think
of it as saying, it
gives you all the integers from
1 up to, but not including, x.
OK.
But now you can see the form.
This now says, OK, let I start
as the first thing in there,
which is 1, and then do
exactly as I did before,
the same thing, but
notice I don't need
to say how to increment it.
It's happening
automatically for me.
OK.
In fact, if I run it,
it does the same thing,
which is what I would expect.
OK.
Now, the advantage of the FOR,
as I said, is that it has,
then, if you like, a
cleaner way of reading it.
I don't have to worry
about, do I initialize it,

Korean: 
같은 코드가 있어요. 
이제, 저는 여러분에게 던져 주거나 몰래 합니다, 
즉, 저는 1부터 10까지 정수 세트를 
어떻게 만들어 내는지 말하지 않았어요. 
그래서, 범위는 장착 된 파이썬 기능입니다. 
저는 곧 그것으로 돌아 올 거에요. 
지금은, 단지 그것에 대해 생각해 보세요. 그것은 여러분에게 
1부터 모든 정수들을 줍니다, 그러나 x를 포함하지 않습니다. 
좋아요. 
그러나 이제 여러분은 형태를 볼 수 있어요. 
이제, 좋아요, 거기서 I를 첫 번째 것으로 시작 합시다, 
그것은 1 이에요. 그리고 나서 제가 전에 한대로 정확히 같은 것을 합니다. 
그러나 제가 그것을 어떻게 증가 시키는지 말할 필요가 없다는 것에 주목하세요. 
그것은 저에게 자동적으로 일어납니다. 
좋아요. 
사실, 제가 그것을 런하면, 그것은 같은 것을 합니다, 
그것은 제가 기대하는 것이지요. 
좋아요. 
이제, FOR의 이점은, 제가 말한 대로, 그것은, 
그것을 읽는 더 깨끗한 방법을 가집니다. 

English: 
did I forget to initialize
it outside the loop,
it happens automatically
just by the syntax of it,
right there, that's going to
start with the first element.
I don't have to
worry about, did I
remember to put
the incrementer in,
it's going to automatically
walk it's way through there.
Second advantage of the FOR
is, that right now, we're
thinking about it just as
a sequence of integers.
We could imagine it's just
counting its way through.
But we're going to
see, very shortly,
that in fact those collections
could be arbitrary.
We're going to have other
ways of building them,
but it could be a collection
of all the primes.
Hm.
There's an interesting
thing to do.
It could be a collection of,
ah, you know, I don't know,
batting averages of
somebody or other.
It could be
arbitrary collections
that you've come up
with in other ways.
The FOR is, again, going to let
you walk through that thing.
So it does not have
to be something
that could be described
procedurally, such as add 1
just to the previous element.
It could be any
arbitrary collection.
And if I were to
use that again, I'd
just put it on your
handout, I could go back
and rewrite that thing
that I had previously
for finding the square roots
of the perfect squares,
just using the FOR loop.
OK.

Korean: 
저는 제가 초기화를 하는지, 루프 밖에서 초기화 하는 것을 잊어 버렸는지 걱정할 필요가 없어요. 
그것은 그것의 문법에 따라 자동적으로 일어납니다. 
저기서, 그것은 
첫 번째 요소부터 시작합니다. 
저는 증가 요소를 두었는지 기억하는 것에 대해 걱정할 필요가 없어요. 
그것은 거기서 자동적으로 
하니까요.  
FOR의 두 번째 이점은, 지금, 우리는 그것을 
정수의 순서로 생각하고 있습니다. 
우리는 그런 방법으로 세는 것을 상상할 수 있습니다.
그러나 우리는 사실 이런 컬렉션들이 제멋대로 일 수 있다는 것을 
매우 간단하게 볼 것입니다. 
우리는 그것들을 만드는 다른 방법을 가질 것이에요. 그러나 그것은 
모든 좋은 컬렉션이 될 것이에요. 
음. 
흥미로운 것이 있습니다. 
그것은 컬렉션 일 수 있어요, 아, 모르겠어요, 
누군가 나 다른 이의 배팅 평균의 컬렉션이요. 
다른 방법으로 여러분이 찾아내는 제멋 대로의 
컬렉션 일 수 있어요. 
다시, FOR는 여러분이 그것을 살펴 보도록 할 것 입니다. 
그래서 그것은 이 전 요소에 1을 더하는 것과 같은 
절차적으로 설명 될 수 있는 것이 
되지 않아도 되요. 
그것은 어떤 제멋 대로의 컬렉션 일 수 있어요. 
그리고 제가 그것을 다시 사용하면, 저는 그것을 여러분의 핸드아웃에 넣을 게요, 
저는 다시 돌아 올 수 있고 제가 완벽한 제곱수의 제곱근을 찾기 위해 
전에 쓴 것을 FOR 루프를 사용해서 
다시 쓸 수 있습니다. 
좋아요. 

English: 
What I want to do, though,
is go on to-- or, sorry,
go back to-- my divisor example.
[UNINTELLIGIBLE PHRASE] OK.
Try again.
I've got a number, I want
to find the divisors.
Right now, what my
code is doing is,
it's printing them up
for me, which is useful.
But imagine I actually wanted
to gather them together.
I wanted to collect them, so I
could do something with them.
I might want to add them up.
Might want to multiply
them together.
Might want to do, I don't
know, something else with them,
find common divisors, of
things by looking at them.
I need, in fact, a
way to make explicit,
what I can't do
that with range, is
I need a way to collect
things together.
And that's going to be the
first of our more compound data
structures, and we have
exactly such a structure,
and it's called a tuple.
This is an ordered
sequence of elements.

Korean: 
그런데, 제가 하려는 것은 – 미안해요, 돌아 갑시다 – 
제 약수 예제 입니다. 
좋아요. 
다시 해 보세요. 
저는 숫자가 있습니다, 저는 약수를 찾으려고 합니다. 
지금, 제 코드가 하는 것은, 그것은 저에게 그것들을 프린트 합니다, 
그것은 유용해요. 
그러나 제가 실제로 그것들을 함께 모으길 원했다고 상상해 보세요. 
저는 그것들을 모으길 원했어요, 그래서 그것들로 무엇을 할 수 있어요. 
저는 그것들을 더하고 싶을 수도 있어요. 
그것들을 곱하고 싶을 수도 있고요. 
모르겠는데, 그것들로 그것들을 봄으로써 그것의 공약수를 찾는 것과 
같은 것을 원할 수도 있어요. 
사실, 저는 명쾌하게 만들 방법이 필요해요, 
제가 범위로 할 수 없는 것은 그것들을 함께 모으는 방법이 필요해요. 
그리고 그것은 우리의 더욱 복합적인 데이터 구조의 첫 번째 것이 될 것입니다. 
그리고 우리는 정확히 구조를 가잡니다, 
그리고 그것을 튜플이라고 합니다. 

English: 
Now, I'm going to
actually add something
to it that's going to make
sense in a little while,
or in a couple of lectures,
which is, it is immutable.
Meaning, I cannot change it, and
we'll see why that's important
later on.
But for now, tuple is this
ordered sequence of structures.
OK.
And how do I create them?
Well, the representation is,
following a square bracket,
followed by a sequence of
elements, separated by commas,
followed by a closed
square bracket.
And that is literally
what I said,
it is an ordered
sequence of elements,
you can see where they are.
OK?
So, let me do a little
example of this.
If I go back over here,
let's define-- er,

Korean: 
이것은 요소의 순서대로 정렬되었어요. 
이제, 저는 실제로 그것에 무언가를 더할 것입니다. 
그것은 말이 되는 것인데, 몇 강의 인데, 
그것은 불변입니다. 
무슨 말이냐 하면, 저는 그것을 변경할 수 없습니다, 
그리고 우리는 왜 나중에 그것이 중요한지 볼 것입니다. 
그러나 지금은, 튜플은 이 구조들의 정렬된 순서 입니다. 
좋아요. 
그리고 제가 그것들을 어떻게 만들어내죠? 
자, 나타나는 것은 꺾쇠 괄호가 나오고, 
다음에 요소들의 순서가 나옵니다, 콤마들과 분리되어, 
닫힌 꺾쇠 괄호가 나옵니다. 
그리고 이것은 정말로 제가 말했던 것입니다, 이것은 요소들의 정렬된 순서에요. 
여러분은 그것들이 어디 있는지 볼 수 있어요. 
네?  
그래서, 저는 이것의 작은 예제를 할 것입니다. 

English: 
can't type-- I can look
at the value of test,
it's an ordered sequence.
I need to get
elements out of it.
So again, I have a
way of doing that.
In particular, I can ask for
the zeroth element of test.
OK, notice, I'm putting a
square bracket around it,
and it gives me-- I know
this sounds confusing,
but this is a long tradition,
it gives me-- ah, yes.
STUDENT: [UNINTELLIGIBLE]
PROFESSOR ERIC GRIMSON: Sorry?
STUDENT: [UNINTELLIGIBLE]
PROFESSOR ERIC GRIMSON:
I created a list here?
Ah, thank you.
I'm glad you guys
are on top of it.
You're saying I want that.
Is that right, John?
Yes?
OK.
Sorry.
You're going to see why this
was a mistake in a little while.
I did not want to
make a list, I wanted
to create a tuple thank
you for catching it.
I want parens, not
square brackets there.
You'll also see in a little
while why both of these things
would work this way, but
it's not what I wanted.
OK?

Korean: 
제가 여기서 돌아가면, 정의해 봅시다 – 타이핑을 할 수 없군요 – 
저는 테스트의 값을 볼 수 있어요, 그것은 정렬 된 순서에요. 
저는 그것의 요소들을 만들어야 해요. 
그래서 다시, 저는 그것을 하는 방법을 가집니다. 
특히, 저는 테스트의 0 번째 요소를 요청할 수 있어요. 
좋아요, 주목하세요, 저는 그 주변에 꺾쇠 괄호를 둘 것입니다, 
그리고 저에게 주세요 – 저는 이것이 혼란스럽게 들리는 것을 알지만, 
이것은 오랜 전통이에요, 그것은 저에게 줍니다 – 아, 네. 
뭐라구요? 
제가 여기서 리스트를 만든다고요? 
아, 고마워요. 
여러분이 그것의 위에 있어서 저는 기쁩니다. 
여러분은 제가 그것을 원한다고 말할 수 있어요. 
맞습니까, 존? 
네? 
좋아요. 
미안해요. 
여러분은 왜 이것이 실수 인지 
잠시 보세요. 
저는 리스트를 만들길 원치 않아요, 저는 그것을 알아 낸 덕분에 
튜플을 만들길 원했어요. 
저는 괄호를 원해요, 저기 꺾쇠 괄호가 아니라요. 
여러분은 또한 왜 그것 두 가지고 이 방법으로 작동하는지 볼 것입니다,  
그러나 그것은 제가 원하던 것은 아닙니다.
네? 

English: 
So I guess I should
go back, and let
me do this correctly this way.
Again, I can look at
test, and I guess test now
if I want to get the
element out-- angle
bracket or square bracket?
I still want square bracket,
that's what I thought-- OK.
Now I can go back
to where I was,
which is a strange
piece of history, which
is, we start counting at 0.
So the-- I hate to
say it this way,
the first element of this tuple
is at position 0, or index 0,
OK?-- so I can get the zeroth
one out, I can get, if I do 2,
I get the third thing out,
because it goes 0, 1, 2--
notice, however, if I do
something that tries to go
outside the length of the tuple
it complains, which is right.
Tuples? also have
another nice structure,
which is, I can go the
other direction, which

Korean: 
그래서 제가 돌아가야 한다고 
생각되네요, 
이것을 이 방법으로 정확하게 해 봅시다. 다시, 저는 테스트를 볼 수 있습니다, 
그리고 제가 요소를 만들어 내길 원하는지 테스트 합니다 – 괄호나 꺾쇠 괄호인가요? 
저는 여전히 꺾쇠 괄호를 원해요, 그것이 제가 생각하던 것이에요 – 네.  
이제 저는 제가 있던 곳으로 돌아 갈 수 있습니다, 
이상한 곳인데, 우리는 0에서 세길 시작합니다. 
그래서 – 저는 이런 방법으로 말하는 걸 싫어해요, 
이 튜플의 첫 번째 요소는 0 위치이고, 또는 인덱스 0 이겠죠, 그렇죠? – 그래서 
저는 0 번째 것을 만들 수 있어요, 제가 2를 하면, 저는 3 번째 것을 만들어요. 
왜냐하면 그것은 0, 1, 2로 증가하기 때문입니다 – 주목하세요, 그러나, 
제가 튜플 길이 밖으로 나가려고 불평하는 것을 하면, 
무엇이 맞나요.
튜플? 또한 좋은 구조를 가집니다, 즉, 저는 
다른 방향으로 갈 수 있어요, 즉, 제가 그것에 음수 인덱스를 주는 그 튜플의 마지막 요소를 

English: 
is, if I want to get the
last element of that tuple
I give it a negative index.
So, imagine, you think of it
as, is it starting right, just
before the beginning
of the thing,
if I give it a 0 it's going
to take the first one,
if I give it a 1, it's
going to take the next one,
but I can go the other
direction, if I give it a -1,
it picks up the last
element of the tuple.
And again, I can go -2, go back.
So this is what we
would call selection.
We can do things like
foo of 0 to get out
the particular element.
I can also pick up
pieces of that tuple.
Again I want to show
you the format here.
If I give it this
strange expression,
this is saying I want to
get the piece of the tuple
starting at index 1, it's
going to be the second element,
and going up to but
not including index 3.
And it gives me back that piece.

Korean: 
얻길 원하면요. 
그래서, 상상해 보세요, 여러분은 그것의 시작 전에, 
그것이 바르게 시작한다고 생각해요, 
제가 그것에 첫 번째 것을 주면, 제가 그것에 1을 주면, 
그것은 다음 것을 가집니다, 그러나 저는 다른 방향으로 갈 수 있어요, 제가 그것에 -1을 주면, 
그것은 튜플의 마지막 요소를 선택합니다. 
그리고 다시, 저는 -2로 갈 수 있어요, 돌아 갑니다. 
그래서 이것은 우리가 선택이라고 부르는 것입니다. 
우리는 특정한 요소를 만들어 내기 위해 foo 같은 것을 
할 수 있어요. 
저는 그 튜플을 또한 고를 수 있어요. 
다시 저는 여러분에게 여기서 형태를 보여주고 싶어요. 
제가 그것에 이 이상한 명령문을 주면, 이것은 
제가 인덱스 1에서 시작하는 튜플을 얻길 원한다고 말합니다, 그것은 
두 번째 요소가 될 것입니다, 그리고 올라가지만 인덱스 
3을 포함하지 않습니다. 
그리고 그것은 저에게 그것을 되돌려 줍니다. 

English: 
Actually a copy of that
piece of the tuple.
This is called slicing.
And then just to complete this.
Two other nice things you
can do with slices are you
can get the beginning
or the end of tuple.
So, for example, if I say TEST
and I don't give it a start
but I give it an end, then
it gives me all the elements
up to that point.
And I can obviously
do the other direction
which is I can say skip to index
2 and all the remaining pieces.
This lets me slice
out, if you like,
the front part or back part or
a middle part of the tuple as I
go along.
What in the world does that have
to do with my divisor example?
Well, actually, before I do that
let me in fact fill in a piece
here.

Korean: 
사실 튜플을 복사한 것입니다. 
이것은 조각 이라고 합니다. 
그리고 나서 이것을 완성하기 위해서요. 
여러분이 조각으로 할 수 있는 두 다른 좋은 것은 여러분이 
튜플의 시작이나 끝을 얻을 수 있다는 것입니다. 
그래서, 예를 들어, 제가 TEST라고 말하고 그것에 
시작을 주지 않지만 끝을 주면, 그것은 저에게 그 점까지의 
모든 요소들을 줍니다.  
그리고 저는 명백히 다른 방향을 할 수 있어요. 
그것은 제가 2와 모든 나머지 것들로 스킵 한다고 말할 수 있는 것이에요. 
이것은 저에게 자르도록 해요. 제가 해 가면서 튜플의 
첫 번째 부분이나 뒷 부분이나 중간 부분을요. 
제 약수 예제와 관련이 있는 것이 
무엇입니까? 
사실, 전에 저는 여기서 그것을 
채우는 것을 했어요. 

English: 
Which is remember I said range
we could think of conceptually
as a tuple -- or sorry as
a sequence of these things.
In fact it gives me
back, now I hate this,
it's actually a list
it's not a tuple.
But for now think
of it as giving you
back an explicit version of
that representation of all
those elements.
You'll see why I'm going
to make that distinction
in a couple of lectures.
All right.
What does this have to do
with my divisor example?
This says I can make tuples,
but imagine now going back
to my divisor example
and I want to gather up
the elements as I go along.
I ought to be able to do
that by in fact just adding
the pieces in.
And that's what I'm
going to do over here.
Which is, let me comment that
out, let me uncomment that.
And I guess I need the
same thing here, right?

Korean: 
그것은 제가 말한 범위를 기억하는 것인데, 우리는 개념적으로 
튜플로써 생각할 수 있어요 – 미안해요 이것들의 순서로써요. 
사실 그것은 제에게 돌려줍니다, 이제 저는 이것을 싫어해요, 
그것은 사실 리스트이지 튜플이 아닙니다.  
그러나 지금은 그것을 여러분에게 모든 요소들을 명백하게 
나타내는 버전을 돌려주는 것으로 생각하세요. 
여러분은 왜 제가 그 구분을 하는지 몇 강의 
안에 알게 될 것입니다.
좋아요. 
제 약수 예제와 관련이 있는 것이 무엇입니까? 
이것은 제가 튜플들을 만들 수 있다고 말합니다, 그러나 이제 
제 약수 예제로 돌아가는 것을 
상상해 보세요 그리고 저는 제가 해 가면서 그 요소들을 모으려고 합니다. 
저는 사실 그것들을 더함으로써 그것을 할 수 
있어야 합니다. 
그리고 그것은 제가 여기서 하려는 것입니다. 
즉, 제가 그것을 comment 하고, 그것을 uncomment 하겠습니다. 
그리고 저는 여기 같은 것이 필요하다고 생각해요, 그렇죠?   

English: 
I need parens not, thank you.
You can tell I'm an
old time list packer.
I really do love these things.
And is that right, John?
OK, so my apologies that
your handout is wrong.
I did not think to check
about the difference
between these things.
Nonetheless, having
done that, let's
look at what I'm going to do.
I now want to run
a loop where I need
to collect things together.
I'm going to give
a name to that.
And what you see there is
I'm going to call divisors
initially an empty tuple,
something has nothing in it.
Right here.
And then I'm going to
run through the same loop
as before, going through this
set of things, doing the check.
Now what I'd like
to do, every time
I find a divisor I'd like
to gather it together.
So I'm going to create a tuple
of one element, the value of i.
And then, ah, cool.
Here's that addition operation
that's badly overloaded.
This is why Professor
Guttag likes and I don't.

Korean: 
저는 괄호가 필요하지 않아요, 고마워요. 
여러분은 제가 오래된 리스트 포장 담당 직원이라고 말할 수 있어요. 
저는 정말 이것들을 좋아합니다. 
그리고 이것은 맞죠, 존? 
좋아요, 여러분의 핸드아웃이 틀렸는데 사과합니다. 
저는 이것들의 차이에 대해 검사해야 한다고 
생각하지 않았어요.
그렇지만, 이것을 다 했으니, 
제가 하려는 것을 봅시다. 
저는 이제 제가 그것들을 모아야 하는 곳에서 
루프를 런하길 원합니다.  
저는 그것에 이름을 줄 것입니다. 
그리고 여러분이 저기서 보는 것은 제가 약수라고 부르는 것입니다. 
처음엔 빈 튜플인데, 안에 아무 것도 없어요. 
바로 여깁니다. 
그리고 나서 저는 전처럼 같은 루프를 통해 런할 것입니다.
이 세트들을 살펴 보고 확인할 것입니다. 
이제 제가 하고 싶은 것은, 제가 약수를 찾을 때 마다 매번 
저는 그것을 함께 모으고 싶어요. 
그래서 저는 i의 값, 한 요소의 튜플을 만들 것입니다. 
그리고 나서, 아, 좋습니다. 
여기에 나쁘게 오버로드된 덧셈 연산이 있어요. 
이것은 구탁 교수가 좋아하고 제가 싫어하는 이유입니다. 

Korean: 
왜냐하면 이것이 튜플이고 저것이 튜플이라고 주어졌을 때, 
저는 그것들을 더할 수 있어요. 
그것은 그것들을 연관시킵니다, 그것의 끝 까지요. 
그리고 제가 계속 그것을 하면, 제가 다 했을 때 약수는 그것의 
컬렉션이 될 것입니다. 
그래서 저가 그것을 런하도록 하겠습니다. 
좋아요. 
이것은 제가 하려는 것입니다 -- 
괄호 안의 i 뒤에 comment가 
있어야 합니다. 
고마워요.  
바로 저기군요. 
좋아요, 우리는 이것을 다시 할 것입니다. 
네. 
그리고 장치들의 세트가 있어요, 
고마워요. 
누가 말했죠? 
누구죠, 없나요? 
학생입니까? 
고마워요. 
그런데 좋은 캐치였어요. 
좋아요, 그래서 이제 여러분은 제가 프로그래밍을 망칠 수 있다는 것을 
볼 수 있습니다, 그것은 제가 했던 것이지요. 
그러나 우리는 그것을 고쳤습니다.
고마워요. 
우리는 무엇을 했죠? 
우리는 이제 그것들을 함께 모으는 
방법을 가집니다, 그렇죠? 
그리고 이것은 우리가 사용하고 싶은 것의 첫 번째 버전입니다. 

English: 
Because given that this is
a tuple and that's a tuple,
I can just add them together.
That is concatenate them, if
you like, one on the end of it.
And if I keep doing that,
when I'm done divisor
will be a collection of things.
So let me just run it.
All right.
This is what I get
for trying to --
STUDENT There
should be a comment
after the i in parentheses.
PROFESSOR ERIC
GRIMSON: Thank you.
Right there.
All right, we'll try this again.
OK.
And there are the
set of devices.
Thank you.
Who did that?
Somebody gets, no?
Yours?
Thank you.
Nice catch too by the way.
All right, so now that you
can see that I can screw up
programming, which I just did.
But we fixed it on the fly.
Thank you.
What have we done?
We've now got a way of
collecting things together,
right?
And this is the first version
of something we'd like to use.
Now that I've gotten
that bound as a name,

English: 
I could go in and
do things with that.
I could go in and say give
me the fourth divisor,
give me the second
through fifth divisor.
Again as I suggested if
I've got two integers
and I want to find
common divisors
I could take those two
lists and walk through them.
I shouldn't say list,
those two tuples,
and walk through them to find
the pieces that match up.
So I've got a way now of
gathering data together.
The last thing I want to
do is to say all right,
now that we've got this idea
of being able to collect things
into collections, we've got
the ability now to use looping
structures as we did before
but we can walk down then doing
things to them, where else might
we have this need to do things
with looping structures?
And I'm going to suggest
you've already seen it.
What's a string?
Well at some level it is an
ordered sequence of characters.
Right?
Now it is not represented
this same way.
You don't see strings
inside these open parens
and closed parens.
You don't see strings
with commas between them,

Korean: 
이제 저는 그 바운드를 이름으로 가집니다, 저는 들어가서 
그것과 함께 할 수 있습니다. 
저는 들어 가서 저에게 네 번째 약수를 달라고, 
다섯 번째 약수를 통해 두 번째 것을 달라고 말할 수 있어요. 
다시 제가 제안한대로 제가 두 정수를 갖고 공약수를 찾길 원하면 
저는 이 두 리스트를 가질 수 있습니다. 
그리고 그것들을 살펴 볼 수 있습니다. 
저는 리스트, 이 두 튜플들을 말해서는 안됩니다 
그리고 그것과 맞는 것을 찾기 위해 살펴 봅니다. 
그래서 저는 데이터를 함께 모으는 방법을 가집니다. 
제가 하려는 마지막 것은 좋아요, 
이제 우리가 그것들을 컬렉션으로 모을 수 있는 이 생각을 가진다는 것입니다, 
우리는 이제 우리가 전에 한 대로 루프 구조들을 사용할 능력을 가집니다 
그러나 우리는 그것들을 하는 것으로 내려 갈 수 있어요, 
우리는 루프 구조가 있는 것이  
어디서 필요하죠? 
그리고 저는 여러분이 그것을 이미 보았다고 생각해요. 
문자열이 무엇이죠? 
어떤 단계에서 그것은 문자들의 정렬된 순서입니다. 
알겠죠? 
이제 그것은 이런 같은 방법으로 나타나지 않습니다.
여러분은 그 괄호 안에 있는 문자열들을 
보지 않습니다. 

English: 
but it has the same
kind of property.
It is in ordered
sequence of characters.
We'd like to do the
same thing with strings.
That is we'd like to be able
to get pieces of them out.
We'd like to be able add them
together or concatenate them
together.
We'd like to be
able to slice them.
And in fact we can.
So strings also support things
like selection, slicing,
and a set of other
parameters, other properties.
And let's just look at that.
Again if I go back here,
let me comment this out.
Right here are a pair of strings
that I've set up, s 1 and s 2.
Let me just run these.

Korean: 
여러분은 그것들 사이의 콤마가 있는 문자열들을 보지 않습니다, 그러나 
그것은 같은 속성을 가집니다. 
그것은 문자들의 정렬 된 순서에 있습니다. 
우리는 문자열로 같은 것을 하고 싶습니다. 
우리는 그것을 만들 수 있고 싶어요. 
우리는 그것들을 더하고 
연결시키고 싶어요. 
우리는 그것들을 자를 수 있고 싶어요.
그리고 사실 우리는 할 수 있습니다.  
그래서 문자열은 또한 선택, 자르기, 
다른 인자들, 다른 속성들과 같은 것을 지지합니다. 
그리고 그것을 봅시다. 
다시 제가 여기로 돌아가면, 이것을 comment 하겠습니다. 
바로 여기 제가 만든 문자열들의 쌍이 있습니다. 
s 1 과 s 2 입니다. 
이것을 런해 보겠습니다. 

Korean: 
우리는 여기로 돌아 갈 수 있습니다. 
그래서 저는 s 1 의 값을 볼 수 있습니다, 그것은 문자열이에요. 
저는 s 1 과 s 2 와 같은 것을 할 수 있어요. 
우리가 전에 본 대로, 그것은 단순히 그것들을 연결시키고 
저에게 더 킨 문자열을 가져다 줍니다. 
그러나 저는 이것의 부분들을 요청할 수 있습니다. 
그래서 예를 들어, 저는 저에게 첫 번째 요소인 
스트링 1, s 1 을 달라고 말할 수 있습니다. 
아, 그것은 정확히 우리가 이것이 그것의 정렬된 순서로 나타나는지를 
생각했던 것이군요. 
다시 저는 첫 번째, 인덱스 9, 첫 번째 것을 말해야 합니다. 
저는 비슷하게 들어가서 인덱스 2와 인덱스 4 사이의 
모든 것을 원한다고 말할 수 있습니다. 
그리고 다시, 그것이 무엇을 하는지 기억하세요. 
인덱스 2는 a 0,   
1, 2 로 시작합니다. 
그리고 나서 그것은 올라가지만 인덱스 4 를 포함하지 않아요. 
그래서 그것은 c와 d를 얻어서 멈춥니다. 
저는 제가 튜플들로 한 것처럼 비슷하게 할 수 있습니다. 

English: 
We can go back over here.
So I can see the value
of s 1, it's a string.
I can do things
like s 1 and s 2.
As we saw before, it simply
concatenates them together
and gives me back
a longer string.
But I can also ask
for parts of this.
So I can, for example, say
give me the first element
of string 1, s 1.
Ah, that's exactly
what we would have
thought if this was represented
as an ordered sequence
of things.
Again I should have said
first, index 0, the first one.
I can similarly
go in and say I'd
like all the things between
index 2 and index 4.
And again, remember
what that does.
Index 2 says start a 0.
1, 2.
So a, b, c.
And then it goes up to
but not including index 4
so it gets c and d
and then it stops.
I can similarly, just as
I did with the tuples,

Korean: 
저는 어떤 점까지 모든 것을 요청할 수 있고 
어떤 점에서 시작해서 계속 하는 것을 요청할 수도 있습니다.
이제 여러분이 여기서 보는 것은 복잡한 데이터 구조의 
시작입니다. 
그리고 좋은 것은 공유된 행동이 
거기 있다는 것이에요. 
제가 튜플들을 그것들의 정렬된 컬렉션으로 가질 수 있는 것처럼, 
문자열은 그것들의 정렬된 컬렉션처럼 행동합니다. 
그래서 저는 문자열을 조작하는 것에 대해 생각하는 것을 시작할 수 있어요. 
저는 그것들을 연관시킬 수 있고, 그것들 
내부에서 찾을 수 있습니다, 저는 사실 그것들로 그것을 할 수 있습니다. 
그리고 여러분에게 제가 원하는 것의 
작은 예제를 보여주겠습니다. . 
가정해 보세요, 저는 이것을 comment 하거나 
말하는 것이 좋을 거 같군요. 
이것을 comment 하겠습니다
제가 수를 가진다고 가정해 보세요. 
저는 수 내부의 모든 숫자들을 더하고 싶습니다. 
저는 그것을 캡쳐하기 위해 제가 설명한 
도구들을 사용할 수 있습니다.  
그래서 제가 무엇을 하길 원하죠? 
저는 왠지 시간에서 각 숫자들로 내려가고 

English: 
I can ask for everything
up to some point
or I can ask for everything
starting at some point
and carrying on.
Now what you're seeing
here then is the beginning
of complex data structures.
And the nice thing
is that there's
a shared behavior there.
Just as I can have tuples as an
ordered collection of things,
strings behave as an ordered
collection of things.
So I can start thinking about
doing manipulation on strings.
I can concatenate them together,
I can find pieces inside
of them, I could actually
do things with them.
And let me show you just
a simple little example
of something I might want to do.
Suppose I take, I better
comment this one out
or it's going to spit it out.
Let me comment that out.
Suppose I take a number.
I'd like to add up all the
digits inside of the number.
I can use the tools
I've just described
in order to capture that.
So what would I want to do?
I'd like to somehow walk
down each of the digits

Korean: 
그것들을 더하고 싶습니다. 
아, 그것이 루프 매커니즘입니다, 그렇죠? 
저는 그것들을 살펴 보는 어떤 방법을 가져야 합니다. 
그것을 하는 쉬운 방법은 FOR의 내부가 되는 것입니다. 
그리고 제가 무엇을 하길 원하죠? 
저는 그 수를 가져와서 그것을 
문자열에 돌려줄 것입니다. 
그래서 제가 여기서 무엇을 하는지에 주목하세요. 
저는 그 수를 가져와서 그것을 문자열로 변환합니다. 
그것이 우리가 전에 한 타입 변환의 예입니다.  
그렇게 함으로써 그것은 제가 그것을 문자들의 정렬된 순서로 
다루는 것을 가능하게 합니다. 
그리고 루프는 무엇을 하죠? 
그것은 FOR c 를 할 것입니다. 그것은 
그 문자열에서 제 이름의 문자입니다. 
그것은 첫 번째로 시작하는 것을 의미합니다, 
저는 그것을 할 것입니다.
그리고 제가 무엇을 하려고 합니까? 
저는 그 문자를 가지고 다시 정수로 변환하고 
어떤 수에 더할 것입니다. 
그리고 저는 여기서 작은 도움이 필요해요, 
그것은 제가 어떤 수 더하기 이것과 같은 수를 가진다고 말했어야 하는 것입니다. 
그러나 그 작은 도움은 정확하게 
같은 것입니다. 
그것은 그 값을 어떤 수에 더하고  
그것을 어떤 수로 돌려 주는 것입니다. 

English: 
one at a time and add them up.
Ah, that's a looping
mechanism, right?
I need to have some way
of walking through them.
An easy way to do it
would be inside of a FOR.
And what would I like to do?
Well I need to take
that number and I'm
going to turn it into a string.
So notice what I'm
going to do right here.
I take that number and
convert it into a string.
That's an example of that type
conversion we did earlier on.
By doing that it makes it
possible for me to treat it
as an ordered sequence
of characters.
And so what's the
loop going to do?
It's going to say
FOR c, which was
my name for the
character in that string.
That means starting
at the first one,
I'm going to do something to it.
And what am I'm going to do?
I'm going to take
that character,
convert it back into an integer,
and add it into some digits.
And I've done a little
short hand here,
which is I should have
said some digits is
equal to some digits plus this.
But that little
short hand there is
doing exactly the same thing.
It is adding that
value into some digits
and putting it back or signing
it back into some digits.
And I'll walk through
that loop and when

Korean: 
그리고 저는 그 루프를 살펴 볼 것입니다. 제가 다 했을 때 
저는 그것이 하는 전체를 프린트 할 수 있습니다. 
그리고 제가 그것을 하면, 저는 제가 예상하는 것을 얻습니다.
그래서 제가 무엇을 얻죠? 
우리는 이제 반복을 이 작은 패턴으로 
하는 생각을 일반화합니다. 
다시 제가 말한 대로 이것은 그것의 제 버전입니다, 그러나 여러분은 지금까지 우리가 사용한 그 패턴을 
가지는 모든 예들을 볼 수 
있습니다. 
제가 무엇을 살펴 보려고 하는지 맞춰 보세요. 
제가 살펴 보려고 하는 것의 컬렉션은 무엇 인가요. 
제가 각 단계에서 하려고 하는 것이 무엇인지 알아 내 보세요. 
마지막 테스트가 무엇인지 알아 내 보세요. 
제가 그것의 마지막에서 하려고 하는 것이 무엇인지 알아 내 보세요. 
저는 그것을 명쾌하게 쓸 수 있습니다. 
저는 그것을 FOR 루프 내부에 쓸 수 있습니다. 
그리고 우리는 더하기를 시작할 것입니다, 
그리고 우리는 구조의 컬렉션의 더 많은 예들을 볼 것입니다. 
그래서 우리는 그것의 세트를 살펴 봄으로써 쉽게 설명될 수 있는 것을 
하려고 하지 않지만 사실 
여러분이 살펴보는 컬렉션이 될 수 있습니다. 
제가 여러분에게 지적하고 싶은 마지막 것은, 
저는 이 리스트로 시작할 것입니다. 
저는 이 리스트에 아무것도 더하지 않았어요, 그렇죠? 

English: 
I'm done I can print out
the total thing does.
And if I do that, I get
out what I would expect.
So what have I done?
We've now generalized
the idea of iteration
into this little pattern.
Again as I said this is my
version of it, but you can see,
every one of the examples
we've used so far
has that pattern to it.
Figure out what I'm
trying to walk through.
What's the collection of things
I'm trying to walk through.
Figure out what I want
to do at each stage.
Figure out what the end test is.
Figure out what I'm going
to do at the end of it.
I can write it explicitly.
I can write it
inside of a FOR loop.
And we've started
to add, and we'll
see a lot more of this, examples
of collections of structures
so that we don't just
have to do something that
can be easily described as
walking through a set of things
but can actually be a collection
that you walk through.
The last thing I want
to point out to you
is, I started out
with this list.
I haven't added anything
to the list, right?

English: 
I mean I've got a different
kind of looping mechanism.
I guess I should say
that's not quite true.
I've added the ability
to have more complex data
structures here.
But I dropped a hint
in the first lecture
about what you could
computer with things.
In fact if you think for
a second about that list,
you could ask what can
I compute with just
that set of constructs?
And the answer is
basically anything.
This is an example
of what is referred
to frequently as being a
Turing complete language.
That is to say with just those
set of constructs, anything
you can describe
algorithmically you can compute
with that set of constructs.
So there's good
news and bad news.
The good news is it
sounds like we're done.
Class is cancelled until final
exam because this is all you
need to know, right?
The bad news is of
course that's not true.
The real issue is to figure
out how to build constructs out
of this that tackle
particular problems,
but the fundamental
basics of computation
are just captured in
that set of mechanisms.
All right, we'll
see you next time.

Korean: 
저는 제가 다른 루프 매커니즘을 가진다는 것을 의미합니다. 
저는 제가 그것이 확실히 옳지 않다고 말해야 한다고 생각해요. 
저는 여기 더 복잡한 데이터 구조들을 
가지는 능력을 더했어요. 
그러나 첫 번째 강의에서 여러분이 
컴퓨터로 할 수 있는 것에 대한 힌트를 주었습니다.  
사실 여러분이 그 리스트에 대해 잠깐 생각해 보면, 
여러분은 질문할 수 있습니다. 제가 그 구조 세트로 무엇을 계산할 수 
있나요? 
그리고 답은 기본적으로 아무 거나 입니다. 
이것은 우리가 종종 Turing 
완벽한 언어로 부르는 것의 예입니다. 
이것은 그 구조 세트를 가지고 여러분이 
알고리즘적으로 설명할 수 있는 것을 말하는 것입니다.
여러분은 그 구조 세트를 계산할 수 있습니다. 
그래서 좋은 뉴스가 있고 나쁜 뉴스가 있습니다. 
좋은 뉴스는 그것은 우리가 한 것처럼 들린다는 것입니다. 
수업은 기말 시험 때까지 취소 될 것입니다 왜냐하면 이것이 여러분이 알아야 할 
모든 것 이니까요, 그렇죠? 
나쁜 소식은 물론 그것이 옳지 않다는 것입니다. 
실제 이슈는 특정한 문제를 다루는 이것의 구조를 만드는 
방법을 알아 내는 것입니다. 그러나 computation 의 근본적인 
기초는 매커니즘 세트에서 
캡쳐 됩니다. 좋아요, 
다음 시간에 봅시다.
