1
00:00:00,000 --> 00:00:06,370

2
00:00:06,370 --> 00:00:08,150
>> 제이슨 허쉬 호른 :에 오신 것을 환영합니다
주 3, 여러분.

3
00:00:08,150 --> 00:00:11,650
우리는 바쁜하지만 흥분이
우리 앞에 절을 참조하십시오.

4
00:00:11,650 --> 00:00:17,010
그래서 첫 번째, 우리는 몇 가지를 만들었습니다 때문에
코스 전진 만, 여전히

5
00:00:17,010 --> 00:00:20,570
학습이 많이 난, 할 떠났다
너희들 일부 자원을 보여 주겠다

6
00:00:20,570 --> 00:00:24,160
그 믿을 수 없을 것으로 증명한다
당신은 접근뿐만 아니라 도움이로

7
00:00:24,160 --> 00:00:28,130
문제는 설정뿐만 아니라, 모든 다이제스트
우리는 당신의 사람을주는 물질

8
00:00:28,130 --> 00:00:30,800
강의와 반바지와 섹션.

9
00:00:30,800 --> 00:00:34,790
>> 그 다음 우리는 처음 20을 보낼거야
섹션에가는 25 분

10
00:00:34,790 --> 00:00:38,630
당신이 나있을 수도 있고 없을 수도 있습니다 GDB,
이 시점에서 사용되고 있지만이며

11
00:00:38,630 --> 00:00:42,570
매우 유용한 도구가 그 것이다
당신은 당신의 프로그램을 디버깅하는 데 도움이됩니다.

12
00:00:42,570 --> 00:00:46,060
여러분의 많은에서의 printf를 사용하고 있습니다
파악하는 프로그램의 중간

13
00:00:46,060 --> 00:00:47,430
변수가 같게 무엇인지.

14
00:00:47,430 --> 00:00:52,060
GDB는 심지어 printf의보다 나은입니다
코드를 망치지 않는 당신 때문에

15
00:00:52,060 --> 00:00:53,320
실행 파일을 실행합니다.

16
00:00:53,320 --> 00:00:56,500
그래서 우리는 10 개의 가장 도움에 갈거야
당신이 GDB에 필요한 명령 및 우린

17
00:00:56,500 --> 00:01:00,540
함께하므로 운동에 갈
문제에서 당신은 세 이후를 설정

18
00:01:00,540 --> 00:01:03,320
디버깅을 돕기 위해 GDB를 사용할 수 있습니다
프로그램.

19
00:01:03,320 --> 00:01:06,420
그리고 마지막으로, 우리는 몇 가지를 통해 갈거야
알고리즘을 정렬 및 검색

20
00:01:06,420 --> 00:01:10,590
당신은 강의에서 본, 우리는 것을
실제로 코드, 단지에가는

21
00:01:10,590 --> 00:01:17,360
의사,하지만 코드 이진 검색,
버블 정렬, 선택 및 정렬.

22
00:01:17,360 --> 00:01:20,090
>> 그래서 일단, 내가 가고 싶어
자원에.

23
00:01:20,090 --> 00:01:23,530
이는 광범위한 목록이며,이야
I가 많이 있었기 때문에 작은 글꼴

24
00:01:23,530 --> 00:01:24,390
여기에 적합하다.

25
00:01:24,390 --> 00:01:26,950
그러나 이것들은, 당신을 도울 것뿐만 아니라
다시, 문제의 세트로와

26
00:01:26,950 --> 00:01:30,760
당신이 배운 소화 정보 만
확실히, 퀴즈 시간은 이러한 것이다 올

27
00:01:30,760 --> 00:01:32,130
매우 도움이 될 수.

28
00:01:32,130 --> 00:01:34,700
그래서 일단, 강의 노트.

29
00:01:34,700 --> 00:01:39,480
당신은 cs50.net/lectures로 이동하는 경우
특정 주 및 일에 스크롤,

30
00:01:39,480 --> 00:01:43,120
당신은 각각의 메모가 있음을 볼 수 있습니다
간단하지 않은, 강의

31
00:01:43,120 --> 00:01:47,250
성적 증명서 만의 편집 된 버전
코드 강의에 덮여 있었는지

32
00:01:47,250 --> 00:01:49,610
미리보기 및 기타 도움이 안주.

33
00:01:49,610 --> 00:01:52,220
내가보기 엔 그 이상가는 것이 좋습니다.

34
00:01:52,220 --> 00:01:55,340
그리고뿐만 아니라, 소스 코드가있다
각 강의에서 사용할 수 있습니다.

35
00:01:55,340 --> 00:02:00,050
그리고 또,이 슬라이드는 것입니다
cs50.net/sections에서 온라인으로 제공

36
00:02:00,050 --> 00:02:01,480
저녁.

37
00:02:01,480 --> 00:02:06,860
>> 그래서 두 번째 단락은 매주됩니다
커버 주제, 일반적으로는 5 ~ 15

38
00:02:06,860 --> 00:02:08,090
길이 분.

39
00:02:08,090 --> 00:02:12,310
그리고 그 희망을 당신에게 줄 것이다
다른 주제에 대한 훌륭한 입문서.

40
00:02:12,310 --> 00:02:12,870
셋째 -

41
00:02:12,870 --> 00:02:16,370
이것은 아주 새로운이 있습니다
년 - study.cs50.net입니다.

42
00:02:16,370 --> 00:02:20,110
당신이 그것을 체크 아웃하지 않은 경우, I
매우 당신이 이렇게하는 것이 좋습니다.

43
00:02:20,110 --> 00:02:21,100
당신은 항목을 선택하세요.

44
00:02:21,100 --> 00:02:23,040
우리는 거기에 주제에 수십 있습니다.

45
00:02:23,040 --> 00:02:24,770
그래서 예를 들어, 기능을 선택합니다.

46
00:02:24,770 --> 00:02:27,270
그것은 당신에게 약간의 슬라이드를 제공합니다
및 기능에주의.

47
00:02:27,270 --> 00:02:31,190
사람들은 실제로 슬라이드되는 TF가
동안 사용하는 것이 좋습니다 우리의

48
00:02:31,190 --> 00:02:32,710
섹션에서 프레 젠 테이션.

49
00:02:32,710 --> 00:02:35,040
처리를위한 팁과 트릭도 있습니다
기능, 그리고 거기에와

50
00:02:35,040 --> 00:02:37,290
도움이 연습 문제
당신은 기능과 함께 작동합니다.

51
00:02:37,290 --> 00:02:41,500
우리는 또한 짧은에 당신에게 링크를 제공합니다
기능 및 배 기능

52
00:02:41,500 --> 00:02:42,750
강의에 올라와있다.

53
00:02:42,750 --> 00:02:46,550
이 때문에 study.cs50.net, 새로운
년, 환상적인 자원.

54
00:02:46,550 --> 00:02:52,180
>> 다음으로, 수동입니다 ​​사람을 가지고
당신이 실행할 수있는 명령

55
00:02:52,180 --> 00:02:52,770
명령 행.

56
00:02:52,770 --> 00:02:57,880
그래서 당신에 관한 질문이있는 경우
명령, 예를 들어, 랜드, 그것은 우리

57
00:02:57,880 --> 00:03:00,900
섹션 중 지난 주에 발생
당신은 가능성이 만난

58
00:03:00,900 --> 00:03:05,380
를 통과 할 때 문제가 설정
코드를 생성,하지만 당신은 사람을 입력하면

59
00:03:05,380 --> 00:03:09,980
랜드, 페이지를 얻을 수 있습니다 그
랜드에 대해 모두 알려줍니다.

60
00:03:09,980 --> 00:03:14,040
그것은, 그것은 무엇이 당신을 제공하는
걸리는 파라미터뿐만 아니라 반환

61
00:03:14,040 --> 00:03:16,530
분류 및 간단한 설명
그 기능의.

62
00:03:16,530 --> 00:03:17,500
>> 그래서 랜드를 확인하세요.

63
00:03:17,500 --> 00:03:22,270
그것은 작은 말의 혼란이 될 수 있습니다
그래서 때때로 나는 것을 발견

64
00:03:22,270 --> 00:03:26,150
단순히 내가 알고 싶은 무엇인가 인터넷 검색
답을 찾을 수있는 가장 좋은 방법입니다.

65
00:03:26,150 --> 00:03:27,940
그래서 구글과 연습.

66
00:03:27,940 --> 00:03:28,600
구글을 잘보세요.

67
00:03:28,600 --> 00:03:30,600
그것은 당신의 가장 친한 친구가 될 것입니다.

68
00:03:30,600 --> 00:03:34,300
>> 뿐만 아니라 구글, 당신은 그것을 찾을 수없는 경우
구글에 cs50.net/discuss, 그건

69
00:03:34,300 --> 00:03:35,550
토론 포럼.

70
00:03:35,550 --> 00:03:39,390
당신은 질문이있는 경우에는 기회가, 하나
당신의 700 + 동료의도가 그

71
00:03:39,390 --> 00:03:42,110
질문하라는 메시지가 표시 될 수 있 습니
그것은 이미 논의에

72
00:03:42,110 --> 00:03:43,540
포럼하고 대답했다.

73
00:03:43,540 --> 00:03:48,130
그래서 당신은 일반적인 질문이나이있는 경우
당신은 당신이 생각하는 질문이

74
00:03:48,130 --> 00:03:52,300
어쩌면 다른 사람에 실행했을 수 있습니다,
cs50.net/discuss를 확인하세요.

75
00:03:52,300 --> 00:03:55,450
>> 마지막으로, 마지막으로 두 사람은, 당신이 원하는 경우
진짜 인간 사무실 이야기

76
00:03:55,450 --> 00:03:57,770
금요일 시간 월.

77
00:03:57,770 --> 00:04:00,850
온라인 근무 시간도 있습니다
연장 학생.

78
00:04:00,850 --> 00:04:04,370
, 그리고 마지막으로 확실히 적어도
나, 느낌표.

79
00:04:04,370 --> 00:04:05,960
당신은 모든 내 연락처 정보가 있습니다.

80
00:04:05,960 --> 00:04:11,940
당신이 무엇이든을 필요로하는 경우에, 결코 없습니다
저에게 연락하는 것을 망설 인다.

81
00:04:11,940 --> 00:04:14,020
항상 이렇게 주시기 바랍니다.

82
00:04:14,020 --> 00:04:17,490
당신의 거의가 Gchat에 저를 추가했습니다,
그래서 실망하고있다

83
00:04:17,490 --> 00:04:20,410
바라건대 그 사이에서 변경됩니다
이것과 다음 절을 참조하십시오.

84
00:04:20,410 --> 00:04:22,105
지금까지 자원에 대한 질문?

85
00:04:22,105 --> 00:04:25,670

86
00:04:25,670 --> 00:04:27,450
좋아요.

87
00:04:27,450 --> 00:04:34,280
>> 마지막으로, 다른 플러그
피드백 sayat.me/cs50.

88
00:04:34,280 --> 00:04:37,050
당신은 나에게 익명의 피드백을 제공 할 수 있습니다
내가하는 방법에 대한.

89
00:04:37,050 --> 00:04:38,320
즉, 지난 주에 정말 도움이되었습니다.

90
00:04:38,320 --> 00:04:41,890
난 너희들의 의견을 몇 가지있어
오른쪽 섹션 플러스에서 후

91
00:04:41,890 --> 00:04:44,750
그것을 본 다른 학생들
주 동안, 그리고

92
00:04:44,750 --> 00:04:46,830
매우 도움이되었다.

93
00:04:46,830 --> 00:04:50,250
나는 시도하고 내 사용을 제한 할 예정
단어 "달콤한"만 표시됩니다 내

94
00:04:50,250 --> 00:04:52,410
열정과 흥분
다른 방법.

95
00:04:52,410 --> 00:04:56,550
그러나 다른 추가가 있었다
실질적인 조언,

96
00:04:56,550 --> 00:04:57,600
흑자와 델타 양.

97
00:04:57,600 --> 00:05:00,480
그래서 나는 너희들에게 의견을주십시오
문제 세트에.

98
00:05:00,480 --> 00:05:01,790
저에게 의견을주고 자유롭게
나의 가르침에.

99
00:05:01,790 --> 00:05:04,010
난 너희들을 위해 여기 있어요.

100
00:05:04,010 --> 00:05:05,270
>> 좋아요.

101
00:05:05,270 --> 00:05:07,020
즉, 내가 가지고있는 모든 것입니다
첫 번째 섹션.

102
00:05:07,020 --> 00:05:08,565
사람은이 있는가
질문 지금까지?

103
00:05:08,565 --> 00:05:12,370

104
00:05:12,370 --> 00:05:14,640
그리고 난에 대한 메모가
제어 센터.

105
00:05:14,640 --> 00:05:21,200
확장 학생들은 나에게 쪽지 한
그들은 어떤 오디오를 얻을 수는 없을 겁니다 말,

106
00:05:21,200 --> 00:05:23,870
하지만 해결하기 위해 내 능력의 부족합니다.

107
00:05:23,870 --> 00:05:25,280
그래서 바라건대, 그 가져
곧 해결.

108
00:05:25,280 --> 00:05:28,850
당신이 온라인으로 시청하는 경우, 안녕,
그러나 당신은 저를들을 수 없습니다.

109
00:05:28,850 --> 00:05:33,860
>> 그래서 첫 번째, 우리는거야
GDB를 통해 이동합니다.

110
00:05:33,860 --> 00:05:37,100
GDB, 앞서 암시로,
디버깅 도구입니다

111
00:05:37,100 --> 00:05:39,040
printf의보다 훨씬 더.

112
00:05:39,040 --> 00:05:44,700
그렇다면, GDB, 너희들을 시작하려면
당신은 당신의 제품을 열려

113
00:05:44,700 --> 00:05:49,070
내가 당신에게 이메일로 파일을
이전 -이 파일은 될 것입니다

114
00:05:49,070 --> 00:05:51,940
비트에서 사용할 수있는 온라인 -

115
00:05:51,940 --> 00:05:55,700
와 GDB를 실행합니다. / 파일의 이름을.

116
00:05:55,700 --> 00:05:58,580
첫째, 물론, 당신은 컴파일 할 필요가
GDB는에서만 작동하기 때문에 파일

117
00:05:58,580 --> 00:05:59,890
실행 파일.

118
00:05:59,890 --> 00:06:02,300
>> 그러나 당신은 시작하려면
GDB, 당신이 할 첫 번째 것은,

119
00:06:02,300 --> 00:06:04,550
당신은 GDB. / 시저를 실행합니다.

120
00:06:04,550 --> 00:06:08,340
그래서 우리가하고있는 프로그램의 이름입니다
지금 함께 갈 예정.

121
00:06:08,340 --> 00:06:12,810
그래서 나는 시저를 만들 쓸거야하는
나에게 실행 파일을 제공합니다

122
00:06:12,810 --> 00:06:14,100
여기에 녹색으로 강조.

123
00:06:14,100 --> 00:06:19,250
그리고 나는 GDB. / 세자르를 실행하는거야.

124
00:06:19,250 --> 00:06:19,810
>> 그리고 거기 당신은 간다.

125
00:06:19,810 --> 00:06:24,540
당신은 우리가 일부 텍스트가 나에게 말하고있다 참조
저를주는 GDB의 버전에 대한

126
00:06:24,540 --> 00:06:27,570
다음 몇 가지 보증 정보, 그리고 우리
정렬 보이는 GDP 프롬프트를 가지고

127
00:06:27,570 --> 00:06:29,350
우리의 명령 프롬프트와 같은,
하지만 당신은 열려 참조

128
00:06:29,350 --> 00:06:32,510
괄호, GDB, 가까운 괄호.

129
00:06:32,510 --> 00:06:36,520
우리는이 파일을 계속하고 디버깅하기 전에
나는 여러분 모두에게 보낸, 이제 살펴 보자

130
00:06:36,520 --> 00:06:40,220
몇 가지 유용한 명령은 그래서 우리는 감각이
무엇 우리가 다루려고하고있다.

131
00:06:40,220 --> 00:06:45,060
>> 이 명령은 여기에 나열되어 있습니다
내가 일반적으로 그들을 사용하는 순서.

132
00:06:45,060 --> 00:06:50,230
그래서 실행하여 내 프로그램을 시작
프로그램의 GBD. / 이름,

133
00:06:50,230 --> 00:06:51,360
이 경우, 시저.

134
00:06:51,360 --> 00:06:57,430
그리고 제일 먼저 나는 99.9 %을
시간의 형 휴식을 의미합니다.

135
00:06:57,430 --> 00:06:59,070
즉, 메인에 브레이크 포인트를 설정합니다.

136
00:06:59,070 --> 00:07:03,260
기본적으로, 당신이 무슨 일을하는지
프로그램에서 멈출 것입니다

137
00:07:03,260 --> 00:07:06,100
주요 그래서 당신은 그것을 선 검사 시작할 수 있습니다
라인으로, 오히려 모든 실행하는 것보다

138
00:07:06,100 --> 00:07:07,040
방법을 통해.

139
00:07:07,040 --> 00:07:09,730
당신은 서로 다른 지점에서 손상 될 수 있습니다
코드는하지만, 주는 일반적으로

140
00:07:09,730 --> 00:07:11,870
시작하기 좋은 장소.

141
00:07:11,870 --> 00:07:14,840
>> I 실행 다음 명령이 실행됩니다.

142
00:07:14,840 --> 00:07:17,400
즉, 프로그램의 실행을 시작하고,
당신은 명령 줄을 입력해야하는 경우

143
00:07:17,400 --> 00:07:19,090
인수는, 당신은 그것을 그 명령을 실행합니다.

144
00:07:19,090 --> 00:07:20,500
인수와 함께 실행합니다.

145
00:07:20,500 --> 00:07:25,000
우리는 버전을 통해가는 그래서 이후
프로그램 너희들이다 C의

146
00:07:25,000 --> 00:07:26,160
PSET 두 쓴 -

147
00:07:26,160 --> 00:07:29,880
이 것은 물론, 몇 가지 버그가 있습니다
희망을 우리가 찾을 수있는 것이있는 -

148
00:07:29,880 --> 00:07:32,810
우리는 몇 가지 명령을 실행을 실행하는거야
행 인수로 인해 시저,

149
00:07:32,810 --> 00:07:34,860
너희들은 문제별로 알고
사양을 설정을합니다

150
00:07:34,860 --> 00:07:36,380
명령 줄 인수.

151
00:07:36,380 --> 00:07:40,000
>> 명령의 다음 커플, 다음
하나는 실제로 다음이라고합니다.

152
00:07:40,000 --> 00:07:42,470
즉, 하나의 선으로 당신 라인 소요
프로그램을 통해.

153
00:07:42,470 --> 00:07:45,800
그래서 입력 후 N 치는 것은 당신에게 소요
다음 라인으로, 실행

154
00:07:45,800 --> 00:07:46,880
이전 행.

155
00:07:46,880 --> 00:07:49,440
단계로 이동합니다뿐만 아니라
다음 라인이지만

156
00:07:49,440 --> 00:07:51,070
당신 내부의 기능을합니다.

157
00:07:51,070 --> 00:07:54,310
그래서 당신은 함수를 작성한 경우
코드 또는 탐구하려는 경우

158
00:07:54,310 --> 00:07:57,820
내가, 예를 들어, 당신은의를 명중하고, 수
오히려 다음 라인에가는 것보다

159
00:07:57,820 --> 00:08:02,390
당신이 바로를 통과하고있는 파일
지금, 당신은 실제로 한 단계 것

160
00:08:02,390 --> 00:08:04,670
이 기능의 코드를 참조하십시오.

161
00:08:04,670 --> 00:08:12,300
>> 목록은 매우 친절 사용자, 당신을 보여줍니다
형식, 약 10 정도 선

162
00:08:12,300 --> 00:08:14,940
현재 코드에서 어디에
그래서 당신은 실제로 파일을 볼 수 있습니다

163
00:08:14,940 --> 00:08:17,810
오히려 다시 교환하는 데보다
등 다른보기 사이.

164
00:08:17,810 --> 00:08:21,890
인쇄, printf와 같다
그 이름에서 알 수 있듯이.

165
00:08:21,890 --> 00:08:24,020
즉, 변수가 동일 무엇을 보여줍니다.

166
00:08:24,020 --> 00:08:25,870
>> 정보의 주민들은 정말 도움이됩니다.

167
00:08:25,870 --> 00:08:27,740
이것은 인쇄의 특별 버전입니다.

168
00:08:27,740 --> 00:08:31,770
정보의 주민들은 당신에게 지역 모두 표시
변수는 당신을 위해 모두를 출력

169
00:08:31,770 --> 00:08:33,380
현재 사용할 수있다.

170
00:08:33,380 --> 00:08:36,360
그래서 대신하는 것보다 일반적으로 I,
난 네 개의 변수를 인쇄

171
00:08:36,360 --> 00:08:39,929
내가 루프에 대한에있어 경우에 대한 호기심
예를 들어, 난 그냥 정보를 주민 쓰기

172
00:08:39,929 --> 00:08:43,470
그리고 그것은 나를 어떻게 내 카운터 내가 보여 줄게
난 배열뿐만 아니라, 동일

173
00:08:43,470 --> 00:08:45,130
등호에서 작동합니다.

174
00:08:45,130 --> 00:08:47,530
>> 마지막으로, 계속합니다.

175
00:08:47,530 --> 00:08:49,300
휴식을 입력하면 당신에게 중지
브레이크 포인트에서.

176
00:08:49,300 --> 00:08:51,380
다음과 같은 방법으로 라인을 통해 걸을 수
다음 단계에 맞춰.

177
00:08:51,380 --> 00:08:55,640
다음에 실행되는 프로그램을 계속
지점을 중단 또는 완료하는 경우까지

178
00:08:55,640 --> 00:08:57,180
더 이상 브레이크 포인트가 있습니다.

179
00:08:57,180 --> 00:09:00,060
사용 안 함은 브레이크 포인트를 제거하면 경우
메인에서 휴식을 결정했다

180
00:09:00,060 --> 00:09:01,890
부적절한 내용에 대해, 당신이 원하는
다른 곳을 설정합니다.

181
00:09:01,890 --> 00:09:05,090
그리고 마지막 질문, 종료, GDB의 밖으로 가져옵니다.

182
00:09:05,090 --> 00:09:10,784
>> 그래서이 프로그램은. / 시저, 우리는거야
지금을보고 우리하기

183
00:09:10,784 --> 00:09:13,490
찾기 위해 GDB를 사용하고자하는
이 프로그램의 버그.

184
00:09:13,490 --> 00:09:18,110
나는 이전에이 프로그램을 실행
(50)을 확인하고, 나는 1 눈살을 얻었다.

185
00:09:18,110 --> 00:09:22,310
모든 것은 그것이 컴파일, 존재, 그것
테스트 많이 통과하지만, 대

186
00:09:22,310 --> 00:09:27,950
어떤 이유로, 그것은 제를 통과하지 못한
에 BARFOO, 모두 대문자를, 선회 시험,

187
00:09:27,950 --> 00:09:33,350
E-D-U-I-R-R, 모두 대문자,
키로 셋을 사용.

188
00:09:33,350 --> 00:09:34,090
나는 아주 가까이있어.

189
00:09:34,090 --> 00:09:35,410
나는 하나의 문자로 내렸다.

190
00:09:35,410 --> 00:09:37,340
그래서 여기에 몇 가지 작은 실수가있다.

191
00:09:37,340 --> 00:09:38,070
내 코드를 통해 보았다.

192
00:09:38,070 --> 00:09:38,850
나는 그것을 알아낼 수 없습니다.

193
00:09:38,850 --> 00:09:41,740
바라 건데, 너희들이 나를 도울 수
이 버그가 무엇인지.

194
00:09:41,740 --> 00:09:44,610
>> 그래서 우리가하고있는 오류의
에 대한 검색.

195
00:09:44,610 --> 00:09:46,090
의는 GDB로 가자.

196
00:09:46,090 --> 00:09:51,100
다시 말하지만, 나는 GDB. / 시저를 실행했습니다
그래서 지금 우리는 GDB에있어.

197
00:09:51,100 --> 00:09:54,290
그리고 첫 번째 것입니다
내가해야 할 일은?

198
00:09:54,290 --> 00:09:56,680
난 그냥 GDB를 입력 한.

199
00:09:56,680 --> 00:10:00,316
누군가가 나에게 좋은 줄
입력하는 명령입니다.

200
00:10:00,316 --> 00:10:01,140
>> 학생 : 주 휴식.

201
00:10:01,140 --> 00:10:01,800
>> 제이슨 허쉬 호른 : 주 휴식.

202
00:10:01,800 --> 00:10:02,900
환상적인.

203
00:10:02,900 --> 00:10:03,560
씨가 들어 그를 입력하자

204
00:10:03,560 --> 00:10:06,390
너희들은 여기에 시청하거나 볼 수 있습니다
컴퓨터에 따라.

205
00:10:06,390 --> 00:10:09,410
주 휴식, 당신은 볼 것이다
브레이크 포인트를 설정 하였다 -

206
00:10:09,410 --> 00:10:12,340
그것은 좀 이상한 메모리 주소를 제공,
그것은 또한 저에게 줄 번호를 제공합니다.

207
00:10:12,340 --> 00:10:15,310
나는이 파일에서 다시 볼 것, 경우
그 기본을 실현합니다

208
00:10:15,310 --> 00:10:17,700
라인 (21)에 일어났다.

209
00:10:17,700 --> 00:10:18,950
나는 다음에 무엇을 실행해야합니까?

210
00:10:18,950 --> 00:10:22,970

211
00:10:22,970 --> 00:10:25,060
내 프로그램을 실행하고 있습니까?

212
00:10:25,060 --> 00:10:25,650
아니오.

213
00:10:25,650 --> 00:10:27,175
그래서 나는 다음에 무엇을 실행해야합니까?

214
00:10:27,175 --> 00:10:27,520
>> 학생 : 실행합니다.

215
00:10:27,520 --> 00:10:28,050
>> 제이슨 허쉬 호른 : 실행합니다.

216
00:10:28,050 --> 00:10:30,760
난 그냥 실행을 실행하거나해야한다
나는 다른 일을에 추가?

217
00:10:30,760 --> 00:10:31,960
>> 학생 : 인수와 함께 실행합니다.

218
00:10:31,960 --> 00:10:33,320
>> 제이슨 허쉬 호른 :와 실행
명령 인수.

219
00:10:33,320 --> 00:10:36,420
그리고 매우 구체적인 디버깅을 해요 이후
경우, 그 입력해야

220
00:10:36,420 --> 00:10:37,120
명령 줄 인수.

221
00:10:37,120 --> 00:10:42,290
그래서 다시, 인, 세 가지를 실행 할 것이다
나는이 지역의 50에서 얻은 출력.

222
00:10:42,290 --> 00:10:44,240
프로그램 시작.

223
00:10:44,240 --> 00:10:45,420
우리는 몇 라인을 통해 이동합니다.

224
00:10:45,420 --> 00:10:47,700
이제 우리는 21 라인 걸 볼 수 있습니다.

225
00:10:47,700 --> 00:10:49,200
어떻게 우리가 선 21 걸 알 수 있습니까?

226
00:10:49,200 --> 00:10:52,170
때문에 당신은 왼쪽에 보면
내 터미널 창,이

227
00:10:52,170 --> 00:10:53,120
그것은 라인 (21)을 말한다.

228
00:10:53,120 --> 00:10:57,010
그리고 실제로, 저를 준다
라인 21에있는 코드.

229
00:10:57,010 --> 00:10:58,440
그래서 이전에 잘못 말한.

230
00:10:58,440 --> 00:10:59,770
주요 라인 (21)에 실제로 아니다.

231
00:10:59,770 --> 00:11:02,000
주 21 위의 몇 줄입니다.

232
00:11:02,000 --> 00:11:04,300
그러나 라인 (21)에, 그의
여기서 우리는 속보입니다.

233
00:11:04,300 --> 00:11:06,280
이 코드 줄은이
아직 실행되지 않습니다.

234
00:11:06,280 --> 00:11:06,890
그게 중요합니다.

235
00:11:06,890 --> 00:11:09,120
당신이 볼 수있는 선이되지 않았습니다
아직 실행되었습니다.

236
00:11:09,120 --> 00:11:12,650
즉, 다음 코드 줄의
당신은 실행하려합니다.

237
00:11:12,650 --> 00:11:15,860
>> 너희들은 그래서 다음 줄,
와 아마 잘 알고,이는

238
00:11:15,860 --> 00:11:20,070
조건 내가 가지고 있는지 확인
명령 줄 인수를 입력했습니다.

239
00:11:20,070 --> 00:11:22,140
그리고 난에, 두 번째는 무엇인가
그 일의 일부?

240
00:11:22,140 --> 00:11:23,457
내가에 무엇입니까?

241
00:11:23,457 --> 00:11:24,950
>> 학생 : 정수로 변경.

242
00:11:24,950 --> 00:11:25,450
>> 제이슨 허쉬 호른 : 죄송합니다?

243
00:11:25,450 --> 00:11:27,400
>> 학생 : 그것은 변화하고
정수로 인수.

244
00:11:27,400 --> 00:11:30,890
>> 제이슨 허쉬 호른 : 그래서 내가 변경에 인수
문자열을 정수로에서 V1.

245
00:11:30,890 --> 00:11:32,140
그리고 그것은 무엇을 확인하는거야?

246
00:11:32,140 --> 00:11:35,414

247
00:11:35,414 --> 00:11:37,112
>> 학생 : 두 번째가있는 경우
명령 줄 인수, 옆으로

248
00:11:37,112 --> 00:11:38,100
프로그램을 실행하십시오.

249
00:11:38,100 --> 00:11:39,460
>> 제이슨 허쉬 호른 : 그리고 무엇
이 후반

250
00:11:39,460 --> 00:11:41,220
부울 식 검사?

251
00:11:41,220 --> 00:11:42,540
여기이 부분은, 난에?

252
00:11:42,540 --> 00:11:44,080
>> 학생 : 음수의 경우.

253
00:11:44,080 --> 00:11:45,380
>> 제이슨 허쉬 호른 : 물론 무엇을 만들기?

254
00:11:45,380 --> 00:11:47,120
>> 학생 : 물론 그것을 만들기
사실, 긍정적이다.

255
00:11:47,120 --> 00:11:47,650
>> 제이슨 허쉬 호른 : 그렇지.

256
00:11:47,650 --> 00:11:50,600
이것은 그것의 있는지 확인한다
그것은 음 음, 그리고 경우에, 나는

257
00:11:50,600 --> 00:11:53,220
느낌이 다음 줄의 힘이
나 사용자 고함 될 수있다.

258
00:11:53,220 --> 00:11:55,930
그래서이 줄을 실행하기 위해 끝을 공격 할 수 있습니다.

259
00:11:55,930 --> 00:11:59,925
우리는 그 라인을 참조하지 않는 너희들
아마 고함을 볼 것으로 예상

260
00:11:59,925 --> 00:12:03,030
사용자가 다음 반환 때문에
이 라인은 실행되지 않았다.

261
00:12:03,030 --> 00:12:03,840
나는 3 들어갔다.

262
00:12:03,840 --> 00:12:06,860
그래서, 사실, 두 가지 명령을 입력 않았다
행 인수, 3입니다

263
00:12:06,860 --> 00:12:07,610
0보다 크다.

264
00:12:07,610 --> 00:12:09,950
그래서 우리는 그 선을보고, 우리는 실행,
그러나 우리는 단계하지 않았다

265
00:12:09,950 --> 00:12:11,300
만약 조건 내부.

266
00:12:11,300 --> 00:12:17,060
>> 그래서 지금, 다음, 내가 설정하고있어 참조
INT 키는 내가 V1 값임에 동일합니다.

267
00:12:17,060 --> 00:12:18,840
그래서 나를 변수 키를 생성합니다.

268
00:12:18,840 --> 00:12:22,450
그래서 지금 키를 인쇄하는 경우, 때문에
그것은 당신이 볼 수 있습니다

269
00:12:22,450 --> 00:12:26,040
값 변수 안에,
키는 47 같습니다.

270
00:12:26,040 --> 00:12:28,810
즉, 물론 이상한, 그러나
내가하지 않은 때문입니다

271
00:12:28,810 --> 00:12:30,490
아직 그 라인을 실행.

272
00:12:30,490 --> 00:12:35,880
I n을 치면 이제, 그 줄을 실행
인쇄 키를 수행 키, 3와 동일합니다

273
00:12:35,880 --> 00:12:37,740
우리가 동일하게 기대하는 것입니다.

274
00:12:37,740 --> 00:12:41,170
>> 그래서 다시, GDB, 라인 당신의
당신이 아직 실행되지 않은 참조하십시오.

275
00:12:41,170 --> 00:12:44,850
당신은 N 또는 S 또는 숫자 쳐야
실제로 다른 명령

276
00:12:44,850 --> 00:12:46,610
그 라인을 실행합니다.

277
00:12:46,610 --> 00:12:47,380
인쇄 키를 누릅니다.

278
00:12:47,380 --> 00:12:48,280
3에서 키의.

279
00:12:48,280 --> 00:12:49,750
지금까지 너무 좋아.

280
00:12:49,750 --> 00:12:51,000
문자열은 일반 텍스트입니다.

281
00:12:51,000 --> 00:12:52,270
의 그 줄을 실행 할 수 있습니다.

282
00:12:52,270 --> 00:12:53,970
나는 사용자로부터 문자열을 받고 있어요.

283
00:12:53,970 --> 00:12:58,690
>> 의 내 지역의 50에 보자, I
BARFOO 모두 대문자를 입력, 그래서

284
00:12:58,690 --> 00:13:01,330
그게 내가 입력 이랍니다.

285
00:13:01,330 --> 00:13:07,300
지금은 일반 텍스트를 인쇄 할 경우.

286
00:13:07,300 --> 00:13:08,610
당신은 문자열을 동일 볼 수 있습니다.

287
00:13:08,610 --> 00:13:11,100
그것은 나에게 다른 이상한 진수를 제공
수 있지만에서 수행

288
00:13:11,100 --> 00:13:13,620
사실은 내 캐릭터가 BARFOO 것을 말한다.

289
00:13:13,620 --> 00:13:19,308
나는 키가에 줄선 무엇을보고 싶어하는 경우
이 때, 내가 어떻게 키 확인 할 수?

290
00:13:19,308 --> 00:13:20,710
>> 학생 : 프린트 키.

291
00:13:20,710 --> 00:13:22,010
>> 제이슨 허쉬 호른 : Print 키, 정확하게.

292
00:13:22,010 --> 00:13:23,260
실제로, 바로 가기가 있습니다.

293
00:13:23,260 --> 00:13:25,910
당신은 인쇄를 입력 질리면,
당신은 P를 입력 할 수 있습니다.

294
00:13:25,910 --> 00:13:28,340
그래서 P 키는 똑같은 일을한다.

295
00:13:28,340 --> 00:13:29,730
그리고 또, 내가 3에 해당 참조하십시오.

296
00:13:29,730 --> 00:13:34,760
>> 나는 어떤 키를 모두 찾아 원하는 경우
및 BARFOO 동시에 같게

297
00:13:34,760 --> 00:13:37,215
하지만 각 입력의 피곤했다
한 중 개별적으로 I

298
00:13:37,215 --> 00:13:38,590
정보의 주민들을 입력 할 수 있습니다.

299
00:13:38,590 --> 00:13:41,170
즉, 나에게 키 같음 3를 제공합니다.

300
00:13:41,170 --> 00:13:42,500
일반 텍스트는 BARFOO 같습니다.

301
00:13:42,500 --> 00:13:45,265
또한 나에게이 두 가지 이상한 일을 준다
상단에,이 변수 i와

302
00:13:45,265 --> 00:13:46,590
이 변수 명.

303
00:13:46,590 --> 00:13:48,460
>> 사람들은 실제로 존재하고
내 주요 프로그램.

304
00:13:48,460 --> 00:13:51,280
우리는 그들을 아직 발생하지 않은
하지만 미리보기로, 그

305
00:13:51,280 --> 00:13:52,880
내에서 루프가 존재한다.

306
00:13:52,880 --> 00:13:55,360
그래서 지금, 그들은 몇 가지 이상한 같아
숫자가되지 않았기 때문에

307
00:13:55,360 --> 00:13:58,300
아직 초기화,하지만 그들은 여전히​​ 존재
메모리에, 그래서 그들은 단지 설정하고

308
00:13:58,300 --> 00:14:00,220
일부 쓰레기 값.

309
00:14:00,220 --> 00:14:02,890
그러나 우리는 일반의 키를 보는가
바로 텍스트.

310
00:14:02,890 --> 00:14:06,390
>> 그래서이 줄을 실행하는거야,
라인 (34), 대한 루프.

311
00:14:06,390 --> 00:14:08,220
우리는 뛰어거야
N 타격에 의해 루프.

312
00:14:08,220 --> 00:14:10,050
그리고 우리는 루프의 내부입니다.

313
00:14:10,050 --> 00:14:11,360
우리는 우리의 첫 번째 체크인시입니다.

314
00:14:11,360 --> 00:14:14,300
그리고 또, 이러한 종류의 보일 것
이 때문에 당신에게 익숙한

315
00:14:14,300 --> 00:14:18,080
시저 작성되었습니다 프로그램,하지만
또, 버그의 일종을 가지고 있습니다.

316
00:14:18,080 --> 00:14:21,940
>> 제가 때문에 지금은, 정보의 주민을하는 경우
for 루프 내에서, 당신은 볼 것이다

317
00:14:21,940 --> 00:14:23,900
우리가 예상 한대로 나는, 0 인 것을.

318
00:14:23,900 --> 00:14:26,820
즉, 우리가 설정 및 초기화 무엇
그것은 루프에 있습니다.

319
00:14:26,820 --> 00:14:27,560
N은 6 같습니다.

320
00:14:27,560 --> 00:14:30,700
우리는 설정 때문은 의미가 있습니다
일반 텍스트의 strlen 함수에 그것.

321
00:14:30,700 --> 00:14:34,270
그래서 정보를 지역 주민 또는 인쇄를 좋아
변수에 자주 있는지 확인합니다

322
00:14:34,270 --> 00:14:36,370
모든 것은 항상 무엇
나는 그것이 같을 것으로 예상된다.

323
00:14:36,370 --> 00:14:39,800
이 경우, 모든이며
나는 그것이 동일하게 기대하는 것.

324
00:14:39,800 --> 00:14:41,850
>> 그럼 통해 이동 시작하자
이 루프.

325
00:14:41,850 --> 00:14:45,715
지금 제가하고있는 라인은 라인 (36)이며, 경우 일반
텍스트 내가 알기보다 큰

326
00:14:45,715 --> 00:14:48,540
텍스트 나보다 작거나 Z와 동일합니다.

327
00:14:48,540 --> 00:14:51,880
내 문제는 내 첫하지 알고
편지, 그 두 번째 문자로입니다.

328
00:14:51,880 --> 00:14:56,290
우리는 확인 되돌아 보면
50, B는 E의 벌금에 간다.

329
00:14:56,290 --> 00:14:59,010
나는를 복용하고로 떠날거야
A, D. 그래서로 변경하지

330
00:14:59,010 --> 00:15:00,200
뭔가 잘못입니다
두 번째 문자.

331
00:15:00,200 --> 00:15:01,640
그래서 이동하는거야
이 두 번째의.

332
00:15:01,640 --> 00:15:06,030
>> 하지만 어떤 일반을 확인하려는 않은 경우
텍스트 나는이 특히 말았 네

333
00:15:06,030 --> 00:15:07,760
경우, 나는 무엇을해야한다고 생각?

334
00:15:07,760 --> 00:15:10,980
일반 텍스트 나는이 동등해야합니까
루프를 통해 첫 라운드?

335
00:15:10,980 --> 00:15:14,046

336
00:15:14,046 --> 00:15:15,110
>> 학생 : 제로?

337
00:15:15,110 --> 00:15:16,510
>> 제이슨 허쉬 호른 : I의 일반 텍스트?

338
00:15:16,510 --> 00:15:21,180
그래서, 나는, 물론 자본 B.해야
= 0하지만, 일반 텍스트

339
00:15:21,180 --> 00:15:25,600
브래킷 제로 폐쇄 브라켓 B와 동일
때문에 문자열, 우리가 지난 주에 본 것처럼,

340
00:15:25,600 --> 00:15:28,650
배열, 그래서 우리가 있어요
그에서 첫 번째 문자.

341
00:15:28,650 --> 00:15:34,960
그래서 다시, 나는의 일반 텍스트를 인쇄하는 경우
난 사실, 문자를받을 수 있나요

342
00:15:34,960 --> 00:15:36,560
B. 그리고 맞아, 굉장 하죠?

343
00:15:36,560 --> 00:15:40,380
실제로 일반 텍스트 I.이 없습니다
그게 내가 설정 한 변수 중 하나 아니에요

344
00:15:40,380 --> 00:15:42,950
또는 초기화되지만 인쇄 할 수 있습니다
사물의 전체 호스트 중

345
00:15:42,950 --> 00:15:45,640
당신은하고 싶은 경우.

346
00:15:45,640 --> 00:15:47,340
>> 그러나의를 통해 이동하자.

347
00:15:47,340 --> 00:15:50,050
일반 텍스트 나보다 크고 경우
일반 텍스트 나보다 작거나 같다

348
00:15:50,050 --> 00:15:53,290
우리가 가지고 있기 때문에 Z, 그건 분명 사실이다
내가 실행하는거야 자본 B.

349
00:15:53,290 --> 00:15:54,230
거기에 몇 가지 명령을 실행합니다.

350
00:15:54,230 --> 00:15:58,530
우리는 지난 주에 그 수학을했다, 그래서 우리는거야
그것이 작동하는 것을 당연하게 받아

351
00:15:58,530 --> 00:16:00,900
바로 50을 확인하는 방법.

352
00:16:00,900 --> 00:16:03,720
>> 이 중괄호, 첫 번째
나는 경우에 종료 된 것으로 나타났다

353
00:16:03,720 --> 00:16:07,030
조건 번째 나타났다
나는 루프를 종료 걸.

354
00:16:07,030 --> 00:16:10,400
나는 다음을 명중 할 때 그리고 지금, 우리는 볼 수 있습니다
우리는 다시 루프 백에서입니다.

355
00:16:10,400 --> 00:16:11,970
우리는을 통해거야
다시 루프.

356
00:16:11,970 --> 00:16:18,110
의 사실은 두 번째 단계 씩하자
루프와 종류의 반복

357
00:16:18,110 --> 00:16:20,520
정보의 주민.

358
00:16:20,520 --> 00:16:22,190
>> 그래서 우리는 두 번째 반복에있어
우리를위한 루프.

359
00:16:22,190 --> 00:16:24,530
나는 우리가 예상하는 1 같습니다.

360
00:16:24,530 --> 00:16:26,650
N은 우리가 기대하는 6 같습니다.

361
00:16:26,650 --> 00:16:28,810
키는 우리가 기대하는 3 같습니다.

362
00:16:28,810 --> 00:16:32,625
일반 텍스트, 당신이 볼 수, 동일
EARFOO는 이제 더 이상 BARFOO 때문이 아니라

363
00:16:32,625 --> 00:16:37,930
우리의 이전의 반복에서, B이었다
자본 E. 변경 그래서 우리는 대략 일

364
00:16:37,930 --> 00:16:40,040
문제가 발생하는,이 때문에
우리가가는 곳입니다

365
00:16:40,040 --> 00:16:41,130
디버깅에 뛰어들.

366
00:16:41,130 --> 00:16:43,365
하지만 아무도 질문이 없습니다
우리가 지금까지 한 일에 대해?

367
00:16:43,365 --> 00:16:46,770

368
00:16:46,770 --> 00:16:47,910
환상적인.

369
00:16:47,910 --> 00:16:52,710
>> 그래서 우리는이 경우를 실행하려합니다
상태, I 폐쇄 일반 텍스트 브래킷

370
00:16:52,710 --> 00:16:57,500
브라켓보다 크고 일반 텍스트 I
이하 Z. 동등하지만 전에

371
00:16:57,500 --> 00:17:00,450
이 때문에는, 그것으로가는 곳
내가 지적하고 싶어요, 내 오류가 알고

372
00:17:00,450 --> 00:17:06,859
I.의 일반 텍스트 밖으로 그래서
의 인쇄를 만들어 보자.

373
00:17:06,859 --> 00:17:12,020
그것은 문자와 동일하지, 그 때문에
지금까지, 모든 것이 잘 좋은 것 같다.

374
00:17:12,020 --> 00:17:14,740
>> 그래서 난 내 논리 당이 선을 기대
이 라인은 진실해야한다.

375
00:17:14,740 --> 00:17:16,099
그것은 자본 편지입니다.

376
00:17:16,099 --> 00:17:20,599
I n을 칠 경우에, 우리는 실현 않는이
라인은, 사실, 실행하지 못했습니다.

377
00:17:20,599 --> 00:17:22,609
나는 다른 사람에 경우 아래로 뛰어 올랐다.

378
00:17:22,609 --> 00:17:25,460
왜 이런 일이 가능?

379
00:17:25,460 --> 00:17:27,480
>> 학생 : 당신이 있기 때문에 당신의 상태
일반 텍스트의 큰

380
00:17:27,480 --> 00:17:29,130
A,하지보다 크거나보다.

381
00:17:29,130 --> 00:17:32,260
>> 제이슨 허쉬 호른 : 그래서 내 일반 텍스트를했다
나는 A, 크지 않은보다 큰

382
00:17:32,260 --> 00:17:32,850
거나 같음.

383
00:17:32,850 --> 00:17:38,130
그래서 명확하게, 자본하지 않았다
상태 경우이 트리거, 우리는 한

384
00:17:38,130 --> 00:17:40,520
한 단계 씩, 우리는하지 않았다
필요한 변화를 할 수 없습니다.

385
00:17:40,520 --> 00:17:41,360
그래서, 실제입니다.

386
00:17:41,360 --> 00:17:42,920
내 버그를 알아 냈어.

387
00:17:42,920 --> 00:17:46,775
내 소스 파일에 다시 갈 수있다,
를 변경하고 업데이트

388
00:17:46,775 --> 00:17:47,855
다시 50을 확인 실행합니다.

389
00:17:47,855 --> 00:17:52,590
>> 그러나 우리는 단지 교육학의 들어 볼 수 있습니다
술, 내가 계속합니다.

390
00:17:52,590 --> 00:17:59,580
다른 사람이하는 경우도 실행하지 않지만
무엇을 대신에 해당하는 명령입니다

391
00:17:59,580 --> 00:18:00,500
그는 변경되지 않습니다.

392
00:18:00,500 --> 00:18:04,840
그래서 전혀 변경하고, 아니라면 I
여기에 일반 텍스트를 인쇄, 우리는가는 볼 수 있습니다

393
00:18:04,840 --> 00:18:08,250
그 통해 루프, 실제로하지 않았다
전혀 그 두 번째 문자를 변경합니다.

394
00:18:08,250 --> 00:18:09,600
아직 자본 A.의

395
00:18:09,600 --> 00:18:12,690
>> 그래서 다시, 우리는 우리의 오류를 디버깅.

396
00:18:12,690 --> 00:18:17,380
우리는이 것을 깨달았다
누락 된 일부 논리.

397
00:18:17,380 --> 00:18:20,590
그리고 우리는 전에 미리 그것을 디버깅
실제로 줄을 실행,

398
00:18:20,590 --> 00:18:24,320
하지만 당신은 눈치 챘을 것입니다 있었다 우리 단지
다음을 명중하고있는 경우 그 다른 점프,

399
00:18:24,320 --> 00:18:26,710
그 의미하는 경우 조건
사실이 아니 었습니다.

400
00:18:26,710 --> 00:18:29,550
우리는 실제로하지 않았다
결과 우리가 예상.

401
00:18:29,550 --> 00:18:33,240
그럼 우리는 메시지가 표시 될 수 있었다 있었다
우리가보고, 그래서 기민한하지

402
00:18:33,240 --> 00:18:38,510
즉, 조건 및 사실 여부를 확인하는 경우
우리의 조건을 평가해야

403
00:18:38,510 --> 00:18:41,150
현재 컨텍스트에서 사실.

404
00:18:41,150 --> 00:18:42,880
>> 즉,이 프로그램을 디버깅에 대한 모든입니다.

405
00:18:42,880 --> 00:18:45,340
아무도 질문이 있습니까?

406
00:18:45,340 --> 00:18:50,486
내가 GDB를 종료하기 위해 무엇을 명령 칠 수 있을까?

407
00:18:50,486 --> 00:18:53,900
Q. 그리고 내가하라는 메시지가 표시됩니다,
어쨌든 종료?

408
00:18:53,900 --> 00:18:54,390
예 또는 아니오.

409
00:18:54,390 --> 00:18:58,440
나는 예에 맞는다, 나는 GDB를 종료해야합니다.

410
00:18:58,440 --> 00:19:00,860
>> 그래서 GDB에 빠른 뇌관이었다.

411
00:19:00,860 --> 00:19:03,430
사실, 실제 시나리오에서,
나는 근무 시간에 이런 짓을.

412
00:19:03,430 --> 00:19:06,710
나는이 정확한 프로그램에서를 GDBed
학생 사무실 시간.

413
00:19:06,710 --> 00:19:12,410
그리고 우리는 우리가 본 명령에 돌아 가면
하기 전에, 우리는 먼저, 휴식 주를 사용

414
00:19:12,410 --> 00:19:13,190
일 우리는했다.

415
00:19:13,190 --> 00:19:16,060
우리는 명령 행 인수와 함께 실행을 사용,
두 번째 것은 우리가했다.

416
00:19:16,060 --> 00:19:18,520
우리는 이동 옆에 많이 사용
라인을 통해 우리.

417
00:19:18,520 --> 00:19:20,310
그리고 또, 짧은 버전
의 다음 n은.

418
00:19:20,310 --> 00:19:22,920
즉, 괄호의
슬라이드에 회색.

419
00:19:22,920 --> 00:19:28,590
>> 우리는 단계를 사용하지 않은,하지만 우리는하지 않았다
반드시이 경우에 필요.

420
00:19:28,590 --> 00:19:32,150
그러나 우리는 나중에 비트에서 사용할 수 있습니다
오늘에 우리가 디버깅하는 경우에 대한

421
00:19:32,150 --> 00:19:36,500
예를 들어, 이진 검색하면 진
검색은 별도의 호출

422
00:19:36,500 --> 00:19:38,200
기능 만있다
그것은 몇 가지 오류가 발생했습니다.

423
00:19:38,200 --> 00:19:40,440
우리는 한 단계 씩 할거야
이진 검색에 전화 및

424
00:19:40,440 --> 00:19:41,840
실제로 디버깅.

425
00:19:41,840 --> 00:19:45,130
우리가 가지고 있기 때문에 우리가 하나를 사용하지 않은 목록
우리의 코드의 좋은 감각, 그러나 만약에 I

426
00:19:45,130 --> 00:19:48,420
어떤 코드의 I의 감각을 얻을 수 원했는가
정도이고, 난 그냥 목록을 사용할 수 있습니다.

427
00:19:48,420 --> 00:19:50,310
>> 우리는, 우리가 사용하는 정보를 지역 주민을 사용하는 인쇄.

428
00:19:50,310 --> 00:19:53,260
우리가 사용할 필요가 없었다 계속
경우, 어느 쪽도 우리가 사용할 필요가 없습니다 않았다

429
00:19:53,260 --> 00:19:55,060
사용하지,하지만 우리가 한 사용 종료합니다.

430
00:19:55,060 --> 00:19:57,850
다시 말하지만,이 10 명령,
을 연습합니다.

431
00:19:57,850 --> 00:20:00,770
당신은이 (10) 명령을 이해한다면,
당신은 어떤 디버깅을 설정해야

432
00:20:00,770 --> 00:20:02,525
GDB와 함께 실행합니다.

433
00:20:02,525 --> 00:20:05,230

434
00:20:05,230 --> 00:20:08,420
>> 그래서 우리는에 다시 갈 것을 대략
단원의 요점은 오늘 연습 해

435
00:20:08,420 --> 00:20:09,720
이러한 정렬 및 검색
알고리즘.

436
00:20:09,720 --> 00:20:14,075
우리가 그렇게하기 전에, 다시, 질문,
GDB에 대한 의견, 우려?

437
00:20:14,075 --> 00:20:16,750

438
00:20:16,750 --> 00:20:20,960
그래서 모든 사람들이 사용하는 것입니다
GDB가 아닌 printf의?

439
00:20:20,960 --> 00:20:24,550
만고의 이익을 위해 그래서 여러분,,
모두가 자신의 머리를 오른쪽으로 고개를 끄덕된다

440
00:20:24,550 --> 00:20:27,400
지금, 그래서 나는 근무 시간에 당신을 볼 수 있습니다
모든 TF가 당신과를 볼 수 있습니다

441
00:20:27,400 --> 00:20:29,460
그들은 방법을 사용하는 저를 보여 말할 것
GDB, 당신은 할 수 있습니다

442
00:20:29,460 --> 00:20:31,240
오른쪽을 표시하는 방법?

443
00:20:31,240 --> 00:20:31,760
종류의?

444
00:20:31,760 --> 00:20:32,640
어쩌면 희망.

445
00:20:32,640 --> 00:20:33,670
쿨.

446
00:20:33,670 --> 00:20:35,790
>> 그래서 우리는로 이동하는 것입니다
정렬 및 검색.

447
00:20:35,790 --> 00:20:40,710
당신은 이미 정렬 된 목록을 볼 수 있습니다
우리, 그러나 그것은하지 않을 것입니다에 대한

448
00:20:40,710 --> 00:20:42,220
항상 사건이 될 수 있습니다.

449
00:20:42,220 --> 00:20:49,170
그래서이 문제에 대한 규격을 설정
문제는 세 가지를 설정, 당신은 반바지를

450
00:20:49,170 --> 00:20:51,410
당신이 실제로보고, 할 수있는
그 팬티를보고하도록 요청합니다.

451
00:20:51,410 --> 00:20:55,090
또한 강의에서 지난 주, 우리는 갔다
이러한 알고리즘의 많은, 그래서 난

452
00:20:55,090 --> 00:20:59,150
가는 클래스에서 시간을 보내고하지 않을
이러한 다시 알고리즘 또는 도면에

453
00:20:59,150 --> 00:21:01,130
어떻게 이들에 대한 사진
알고리즘이 작동합니다.

454
00:21:01,130 --> 00:21:04,030
다시 말하지만, 당신이 다시 볼 수 있다는 정보
강의, 또는 그 정보

455
00:21:04,030 --> 00:21:08,570
반바지에 뛰어나게 포착
이러한 검색, 모두를위한

456
00:21:08,570 --> 00:21:10,920
cs50.net에서 사용할 수있는.

457
00:21:10,920 --> 00:21:14,200
>> 그래서 그 대신, 우리는거야
할이 프로그램을 작성합니다.

458
00:21:14,200 --> 00:21:18,190
우리는 방법의 정신 모델을, 감각이
그들이 작동, 그래서 우리는거야

459
00:21:18,190 --> 00:21:20,210
할 것은 진짜를 코드입니다.

460
00:21:20,210 --> 00:21:23,430
우리는 정신 모델을 설정하는 것입니다,
그 사진, 당신이 경우,에

461
00:21:23,430 --> 00:21:24,960
실제 코드.

462
00:21:24,960 --> 00:21:28,460
그리고 당신은 약간의 혼란 또는 인 경우
정신 모델에 흐릿한, 나는 완전히

463
00:21:28,460 --> 00:21:28,770
이해합니다.

464
00:21:28,770 --> 00:21:30,540
>> 우리는 실제로는 안돼
코드 직선으로 이동합니다.

465
00:21:30,540 --> 00:21:36,030
이 슬라이드에서이 메시지가 요청하는 동안 그래서
당신은 이진 검색을 코딩하고, 수

466
00:21:36,030 --> 00:21:39,470
실제로, 반복 버전
이진 검색, 제일 먼저 I

467
00:21:39,470 --> 00:21:42,370
정말 당신이되고 싶어
일부 의사 코드를 작성합니다.

468
00:21:42,370 --> 00:21:47,020
그래서 당신은이 정신 모델을
얼마나 이진 검색 작품.

469
00:21:47,020 --> 00:21:50,060
만약 당신이 종이 한 장을 꺼내
하나는 쉽게 사용할 수, 또는 열

470
00:21:50,060 --> 00:21:52,520
텍스트 편집기, 그리고 내가 좋아하는 것
쓸 수있는 사람.

471
00:21:52,520 --> 00:21:57,470
쓰기 4 분 타고
이진 검색을위한 의사.

472
00:21:57,470 --> 00:21:58,990
>> 다시 말하지만, 그 정신 모델에 대해 생각합니다.

473
00:21:58,990 --> 00:22:01,980
당신은 질문이있는 경우에는 내가 돌아올거야
우리는 그림을 그릴 수 있습니다.

474
00:22:01,980 --> 00:22:06,220
그러나 첫째로, 우리는 프로그래밍을 시작하기 전에,
내가 쓰고 싶은

475
00:22:06,220 --> 00:22:09,920
이진 검색을위한 의사 그렇게 할 때 우리
다이빙, 우리는 몇 가지 방향이

476
00:22:09,920 --> 00:22:12,110
우리가 머리를해야 곳.

477
00:22:12,110 --> 00:22:15,330
>> 학생 : 우리는 배열을 가정 할 수있다
우리가 얻는 값은 이미 정렬?

478
00:22:15,330 --> 00:22:17,960
>> 제이슨 허쉬 호른 : 그래서 이진 검색을위한
작동하도록 - 우수 질문 - 만약 당신이

479
00:22:17,960 --> 00:22:20,970
정렬에 걸릴해야
값의 배열입니다.

480
00:22:20,970 --> 00:22:22,290
그래서 작동합니다 가정합니다.

481
00:22:22,290 --> 00:22:23,480
우리는 다시이 슬라이드로 이동합니다.

482
00:22:23,480 --> 00:22:27,220
당신은 보라색 함수에서 볼 수 있습니다
선언은 부울 binary_search의 INT입니다

483
00:22:27,220 --> 00:22:29,230
값, INT 값, INT n을.

484
00:22:29,230 --> 00:22:32,910
당신이 나있는 경우에이 익숙 할 것이다
이미 접근 또는 입수하여

485
00:22:32,910 --> 00:22:34,580
문제 세트 더러운 손.

486
00:22:34,580 --> 00:22:35,910
>> 하지만 함수 선언입니다.

487
00:22:35,910 --> 00:22:39,080
또, 걱정 할 필요가 없습니다
이 순간에 그 정도.

488
00:22:39,080 --> 00:22:43,660
내가 정말 원하는 것은 걸릴 것입니다
의사 이진 사분

489
00:22:43,660 --> 00:22:46,380
검색 한 다음 우리가 간다
그룹으로 그 이상.

490
00:22:46,380 --> 00:22:47,500
그리고 주변에 올 것이다.

491
00:22:47,500 --> 00:22:49,590
당신은 질문이있는 경우에는, 느낌
손을 들어 무료.

492
00:22:49,590 --> 00:25:07,110

493
00:25:07,110 --> 00:25:09,680
>> 왜 두 분 이상 소요되지 않는다
의사를 마무리하는?

494
00:25:09,680 --> 00:25:13,690

495
00:25:13,690 --> 00:25:15,820
나는이 그 말도 안되는 것처럼 보일 수 있습니다 알고
우리는 너무 많은 시간을 소비하고

496
00:25:15,820 --> 00:25:20,350
에도 사실이 아니다 뭔가
C하지만, 특히이 더 많은 것을 위해

497
00:25:20,350 --> 00:25:24,030
도전 알고리즘과 문제
우리가 파악해야 세트,

498
00:25:24,030 --> 00:25:27,210
의사는 걱정하지에서 시작
구문에 대해, 단지에 대한 걱정

499
00:25:27,210 --> 00:25:29,150
논리는 매우 도움이됩니다.

500
00:25:29,150 --> 00:25:32,720
그리고 그 방법은 두 가지를 해결하지 않을
한 번에 믿을 수 없을만큼 어려운 문제.

501
00:25:32,720 --> 00:25:35,390
당신은 논리에 집중하고있어
다음 구문으로 이동합니다.

502
00:25:35,390 --> 00:25:59,960

503
00:25:59,960 --> 00:26:01,385
>> OK.

504
00:26:01,385 --> 00:26:03,680
의를 통해가는 시작하자
의사.

505
00:26:03,680 --> 00:26:05,380
나는 진, 여기에 쓴
검색 의사.

506
00:26:05,380 --> 00:26:07,360
우리는에이를 쓸 것이다
함께 탑승.

507
00:26:07,360 --> 00:26:10,040
아니면 내가 쓸거야, 그리고 줄 것이다
나 내가 필요한 지시.

508
00:26:10,040 --> 00:26:15,010
그래서 아무도 나에게 먼저 제공 할 수 있습니다
의사의 라인 입력

509
00:26:15,010 --> 00:26:18,350
이진 검색을 위해 쓴거야?

510
00:26:18,350 --> 00:26:20,258
예, 애니?

511
00:26:20,258 --> 00:26:22,698
>> STUDENT : 동안의 길이
리스트는 0보다 크다.

512
00:26:22,698 --> 00:26:26,114

513
00:26:26,114 --> 00:26:34,880
>> 제이슨 허쉬 호른 : 동안 길이
의 0보다 큰 목록.

514
00:26:34,880 --> 00:26:38,810
그리고 다시, 우리는 몇 가지 C-찾고 참조
여기에 구문 가지.

515
00:26:38,810 --> 00:26:41,550
하지만이 중 대부분은 영어로되어 있습니다.

516
00:26:41,550 --> 00:26:43,980
아무도 그들이 넣어 모든 줄이나요
자신의 의사 코드에서이 전에?

517
00:26:43,980 --> 00:26:47,280

518
00:26:47,280 --> 00:26:50,210
>> 학생 : 배열을보세요
의 숫자를 정렬.

519
00:26:50,210 --> 00:26:53,600
>> 제이슨 허쉬 호른 : 당신이 쓴 "얻을
정렬 된 숫자의 배열입니다. "당

520
00:26:53,600 --> 00:26:56,140
함수 선언, 우리는 전달됩니다
정렬 된 숫자의 배열입니다.

521
00:26:56,140 --> 00:26:57,280
>> 학생 : [청취].

522
00:26:57,280 --> 00:26:59,030
>> 제이슨 허쉬 호른 : 그래서
우리는 그것을해야합니다.

523
00:26:59,030 --> 00:27:01,820
하지만 그래, 우리는 그것을하지 않은 경우 우리
우리의 배열을 정렬 할 필요가

524
00:27:01,820 --> 00:27:04,850
숫자 때문에 이진 검색
만 분류되어 배열에서 작동합니다.

525
00:27:04,850 --> 00:27:11,300
목록의 길이가 0 인 그래서 동안, 난
일부 괄호에 넣어 것

526
00:27:11,300 --> 00:27:15,420
그것은 조금 더처럼 보이게
C. 그러나 동안은에 매핑하는 것

527
00:27:15,420 --> 00:27:19,550
루프 동안, 그래서이 동안​​ 내부
루프는 우리는 무엇을해야합니까

528
00:27:19,550 --> 00:27:22,000
이진 검색을 위해 할?

529
00:27:22,000 --> 00:27:25,530
>> 나에게 부여하지 않은 다른 사람
아직 답변을하지만 누가 쓴?

530
00:27:25,530 --> 00:27:31,750

531
00:27:31,750 --> 00:27:33,320
>> 학생 : 목록의 중간으로 이동합니다.

532
00:27:33,320 --> 00:27:33,980
>> 제이슨 허쉬 호른 : 톰.

533
00:27:33,980 --> 00:27:35,230
목록의 가운데로 이동합니다.

534
00:27:35,230 --> 00:27:43,290

535
00:27:43,290 --> 00:27:45,530
그리고 후속 질문, 어떤
우리가에있어 일단 우리가해야합니까

536
00:27:45,530 --> 00:27:46,870
목록의 중간?

537
00:27:46,870 --> 00:27:49,310
>> 학생 : 그건 여부를 체크하세요
당신이 찾고있는 번호입니다.

538
00:27:49,310 --> 00:27:50,120
>> 제이슨 허쉬 호른 : 좋음.

539
00:27:50,120 --> 00:28:05,500
목록의 중간에 가서 확인
우리의 가치가있는 경우 -

540
00:28:05,500 --> 00:28:06,515
환상적인.

541
00:28:06,515 --> 00:28:10,460
사람은 무엇을 했습니까
즉,이 다른했다?

542
00:28:10,460 --> 00:28:11,210
그게 바로 그렇습니다.

543
00:28:11,210 --> 00:28:13,800
>> 우리는 이진 검색에 우선 할 일은
목록의 중간으로 이동하고

544
00:28:13,800 --> 00:28:15,870
우리의 값이 있는지 확인합니다.

545
00:28:15,870 --> 00:28:19,682
우리의 값이 있다면 나는 가정
우리는 무엇을이해야합니까?

546
00:28:19,682 --> 00:28:21,610
>> 학생 : 우리는 [청취] 0을 반환.

547
00:28:21,610 --> 00:28:23,400
>> 제이슨 허쉬 호른 : 네, 만약에 우리
값이, 우리는 그것을 발견했다.

548
00:28:23,400 --> 00:28:27,950
그래서 우리는하지만, 어떤 방법을 말할 수있는이
함수가 정의되고, 우리는 사용자를 말한다

549
00:28:27,950 --> 00:28:28,520
우리는 그것을 발견했다.

550
00:28:28,520 --> 00:28:30,950
그것은이없는 경우에, 그러나, 그건
이 까다로운 얻을 곳.

551
00:28:30,950 --> 00:28:35,120
그래서이 아니라면, 다른 사람 누구
이진 검색이나 작업을했다

552
00:28:35,120 --> 00:28:36,830
지금, 우리는 무엇을 생각해야합니까했다?

553
00:28:36,830 --> 00:28:37,830
>> 학생 : 질문.

554
00:28:37,830 --> 00:28:38,100
>> 제이슨 허쉬 호른 : 예?

555
00:28:38,100 --> 00:28:39,920
>> 학생 : 배열이 이미 정렬되어 있습니까?

556
00:28:39,920 --> 00:28:42,200
>> 제이슨 허쉬 호른 : 예, 우리는 가정입니다
배열이 이미 정렬됩니다.

557
00:28:42,200 --> 00:28:46,480
>> 학생 : 그럼 당신은 확인해야 할 경우
당신이 볼 수있는 값보다 큰

558
00:28:46,480 --> 00:28:51,745
당신이 원하는 가치, 당신은 이동할 수 있습니다
나머지 절반의 중간에.

559
00:28:51,745 --> 00:28:54,110
>> 제이슨 허쉬 호른 : 그래서 경우의 중간
목록은 우리가있어 무엇보다 큰

560
00:28:54,110 --> 00:28:57,440
무엇을 위해 우리가 할 찾고?

561
00:28:57,440 --> 00:28:58,320
우리는 위치를 이동?

562
00:28:58,320 --> 00:29:01,400
>> 학생 : 당신은로 이동할
함께리스트 반

563
00:29:01,400 --> 00:29:02,780
보다 낮은 숫자.

564
00:29:02,780 --> 00:29:04,460
>> 제이슨 허쉬 호른 : 그래서 우리는거야
왼쪽이 호출합니다.

565
00:29:04,460 --> 00:29:15,435
중간이 큰 경우에, 우리는 검색 할 수 있습니다
목록의 왼쪽 절반.

566
00:29:15,435 --> 00:29:20,620

567
00:29:20,620 --> 00:29:22,980
다음 검색에 의해, 무엇을
내가 검색을 통해 의미합니까?

568
00:29:22,980 --> 00:29:24,010
>> 학생 : [청취].

569
00:29:24,010 --> 00:29:24,410
>> 제이슨 허쉬 호른 : 우리는 중앙으로 이동합니다.

570
00:29:24,410 --> 00:29:25,740
우리는 실제로이 일을 반복합니다.

571
00:29:25,740 --> 00:29:29,210
우리는 우리의 while 루프를 통해 다시 이동합니다.

572
00:29:29,210 --> 00:29:31,480
나는 당신에게 마지막 하나를 줄 것이다 -

573
00:29:31,480 --> 00:29:39,047
다른 경우, 중간보다 작
우리는, 우리가 여기서 무엇을해야합니까?

574
00:29:39,047 --> 00:29:40,360
>> 학생 : 오른쪽으로 이동합니다.

575
00:29:40,360 --> 00:29:41,610
>> 제이슨 허쉬 호른 : 오른쪽 검색.

576
00:29:41,610 --> 00:29:47,440

577
00:29:47,440 --> 00:29:51,710
이 좋아 보인다, 그러나 누구가 있는가
우리가 없거나 할 수있다 아무것도

578
00:29:51,710 --> 00:29:53,200
당신은 넣어 그 무엇
당신의 의사 코드에서?

579
00:29:53,200 --> 00:29:57,080

580
00:29:57,080 --> 00:29:58,410
그래서 이것은 우리가 지금까지 것입니다.

581
00:29:58,410 --> 00:30:00,960
리스트의 길이는 큰 반면
0보다, 우리가 갈 예정입니다

582
00:30:00,960 --> 00:30:03,220
목록의 중간에
우리의 값이 있는지 확인합니다.

583
00:30:03,220 --> 00:30:06,970
>> 중간이 큰 경우, 우리는거야
중간 인 경우 검색 다른, 왼쪽

584
00:30:06,970 --> 00:30:09,230
이하, 우리는 권리를 검색 할 것입니다.

585
00:30:09,230 --> 00:30:14,430
그래서 우리는 모두 어느 정도 익숙 했어
우리는 컴퓨터 과학에서 사용하는 용어

586
00:30:14,430 --> 00:30:15,550
그리고 도구는 우리가.

587
00:30:15,550 --> 00:30:18,300
하지만 당신은 이미 우리가 있었던 알 수 있습니다
영어로 말하기, 그러나 우리는 발견

588
00:30:18,300 --> 00:30:24,790
에 매핑하는 듯 많은 것
우리는 우리의 코딩 도구 키트에이 도구를 제공합니다.

589
00:30:24,790 --> 00:30:27,210
그래서 바로 박쥐, 우리는 아니에요
아직 실제로 코딩하는 것.

590
00:30:27,210 --> 00:30:33,300
>> 우리가 영어로 무슨 일을 볼 않는지도
볼거리에에 우리는 C에서 쓸 수 있는가?

591
00:30:33,300 --> 00:30:34,560
>> 학생 :있다.

592
00:30:34,560 --> 00:30:35,320
>> 제이슨 허쉬 호른 : 동안.

593
00:30:35,320 --> 00:30:40,610
그래서 동안이 바로 여기
무엇에 대한지도?

594
00:30:40,610 --> 00:30:42,630
>> 학생 : While 루프.

595
00:30:42,630 --> 00:30:43,200
>> 제이슨 허쉬 호른 : while 루프?

596
00:30:43,200 --> 00:30:44,540
또는 아마도, 더 일반적으로, 루프.

597
00:30:44,540 --> 00:30:46,260
우리는 반복 작업을 수행합니다.

598
00:30:46,260 --> 00:30:49,050
그래서 우리는 루프를 코딩하는 것입니다.

599
00:30:49,050 --> 00:30:51,640
우리가 한 때문에 우리는 이미 알고있다
이 시대의 부부와 우리

600
00:30:51,640 --> 00:30:54,180
, 거기에 많은 예를
실제로 어떻게 작성하는 방법

601
00:30:54,180 --> 00:30:55,310
루프에 대한이 인덱스.

602
00:30:55,310 --> 00:30:56,160
그래서 아주 쉽게해야합니다.

603
00:30:56,160 --> 00:30:58,070
우리는 그것을 얻을 수 있어야합니다
꽤 빨리 시작했다.

604
00:30:58,070 --> 00:31:01,830
>> 또 우리가 여기에서 볼 수 있습니까?

605
00:31:01,830 --> 00:31:06,820
다른 어떤 구조 문법, 일
우리가 C에 익숙한 것으로, 우리가 할

606
00:31:06,820 --> 00:31:09,790
이미 기반의 감각이
우리가 사용하는 단어의 해제?

607
00:31:09,790 --> 00:31:10,830
예, 안나?

608
00:31:10,830 --> 00:31:11,360
[청취]

609
00:31:11,360 --> 00:31:12,990
그냥 농담.

610
00:31:12,990 --> 00:31:13,540
안나, 진행.

611
00:31:13,540 --> 00:31:14,530
>> 학생 : 그리고 만약 다른.

612
00:31:14,530 --> 00:31:16,260
>> 제이슨 허쉬 호른 : 경우
다른 - 바로 여기.

613
00:31:16,260 --> 00:31:18,840
그래서 사람들처럼 보이나요?

614
00:31:18,840 --> 00:31:20,420
>> 학생 : 다른 if 문.

615
00:31:20,420 --> 00:31:21,560
>> 제이슨 허쉬 호른 : 네,
조건, 오른쪽?

616
00:31:21,560 --> 00:31:24,650
그래서 우리는 아마해야합니다
몇 가지 조건을 작성합니다.

617
00:31:24,650 --> 00:31:31,185
그리고 다시,하지만 어쩌면에 혼란
첫째, 우리는 일반적으로 지금 감각이

618
00:31:31,185 --> 00:31:34,010
조건을 작성하는 방법
조건 구문.

619
00:31:34,010 --> 00:31:36,850
우리가하지 않으면, 우리는 그냥보고
조건, 잘라 내기 및 붙여 넣기를위한 구문

620
00:31:36,850 --> 00:31:39,950
즉, 우리는 우리가 알고 있기 때문에
여기에 조건이 필요합니다.

621
00:31:39,950 --> 00:31:44,910
우리는에 그지도를 볼 다른 것들
우리는 C에서 수행해야 할 수도 있습니다 것들?

622
00:31:44,910 --> 00:31:48,312

623
00:31:48,312 --> 00:31:48,960
그래, Aleha?

624
00:31:48,960 --> 00:31:50,370
>> 학생 :이 분명있을 수 있습니다
단지 확인했을 경우

625
00:31:50,370 --> 00:31:51,990
값은 무엇인가 같습니다.

626
00:31:51,990 --> 00:31:54,578
>> 제이슨 허쉬 호른 : 그래서 우리가 어떻게 확인합니까
와 - 그래서 목록의 중간으로 이동

627
00:31:54,578 --> 00:31:55,610
우리의 값이 경우 확인?

628
00:31:55,610 --> 00:31:56,570
우리가이 C에서 어떻게해야합니까?

629
00:31:56,570 --> 00:31:58,450
이 구문은 무엇입니까?

630
00:31:58,450 --> 00:31:59,235
>> 학생 : 같음, 같음.

631
00:31:59,235 --> 00:32:00,650
>> 제이슨 허쉬 호른은 : 같음, 같음.

632
00:32:00,650 --> 00:32:03,540
그래서이 검사는 아마 것입니다
등호로, 동일합니다.

633
00:32:03,540 --> 00:32:04,510
그래서 우리는 우리가 그 곳을 필요로 알 수 있습니다.

634
00:32:04,510 --> 00:32:07,510
실제로, 그냥 서면,
우리는 그 무엇을 참조하십시오.

635
00:32:07,510 --> 00:32:11,400
우리는 몇 가지 작업을 수행해야 할 것입니다
비교 연산자가있는 -

636
00:32:11,400 --> 00:32:12,010
환상적인.

637
00:32:12,010 --> 00:32:14,980
그래서 실제로 같은 의해 보인다
큰, 우리가 작성하지 않았습니다

638
00:32:14,980 --> 00:32:16,390
아직 C 코드의 단어입니다.

639
00:32:16,390 --> 00:32:20,610
그러나 우리는 아래로 정신 모델을 가지고
강의와 그 반바지를 통해.

640
00:32:20,610 --> 00:32:22,350
>> 우리는 그룹으로 의사 코드를 썼다.

641
00:32:22,350 --> 00:32:27,110
이미, 우리는 80 %가 아닌 경우,이
우리가해야 할 일의 90 %.

642
00:32:27,110 --> 00:32:28,550
이제, 우리는 단지 코딩해야
그것은 다시하는 것입니다

643
00:32:28,550 --> 00:32:30,110
해결이 아닌 사소한 문제.

644
00:32:30,110 --> 00:32:31,890
그러나 적어도 우리는 논리에 붙어있어.

645
00:32:31,890 --> 00:32:38,040
우리는 근무 시간에 갈 때 지금은 적어도
나는 내가 원하는 것을 알고, 말할 수

646
00:32:38,040 --> 00:32:40,160
할 수 있습니다,하지만 당신은 생각 나게 할 수있다
구문의 날?

647
00:32:40,160 --> 00:32:42,940
아니면 근무 시간은 당신에게, 혼잡 한 경우에도
오히려, 구문 구글 수

648
00:32:42,940 --> 00:32:45,040
논리에 붙어 것보다.

649
00:32:45,040 --> 00:32:48,570
>> 그리고 다시이 아닌 해결하기 위해 노력하고
논리와 문법 문제를 모두

650
00:32:48,570 --> 00:32:51,900
한 번에, 그것은 종종 훨씬 더
로 그 두 개의 하드 문제를 해소

651
00:32:51,900 --> 00:32:58,280
두 더 관리 것들과 할
C.의 의사 코드 먼저 다음 코드

652
00:32:58,280 --> 00:33:00,620
그럼에 대해 내가 무슨 짓 보자
의사 코드를 미리.

653
00:33:00,620 --> 00:33:04,060
>> 리스트의 길이는 큰 반면
0보다, 중간보고

654
00:33:04,060 --> 00:33:05,090
목록.

655
00:33:05,090 --> 00:33:09,610
수 다른, 진정한 반환 발견하는 경우
수 높은 검색 왼쪽 경우.

656
00:33:09,610 --> 00:33:13,200
다른 경우 낮은 번호 검색
오른쪽 false를 반환합니다.

657
00:33:13,200 --> 00:33:18,710
그래서 거의 동일하게 인식하지 않을 경우
우리가 쓴 거의 동일합니다.

658
00:33:18,710 --> 00:33:23,030
사실, 톰, 당신이 먼저 말을,
리스트의 경우와 중간 속보

659
00:33:23,030 --> 00:33:24,880
두 문장으로 찾을 수
내가 무슨 짓을했는지 사실이다.

660
00:33:24,880 --> 00:33:25,507
>> 나는 그들을 거기 결합.

661
00:33:25,507 --> 00:33:27,100
나는 경청해야
당신이 처음.

662
00:33:27,100 --> 00:33:30,640
그래서 우리가 가지고있는 의사 코드입니다.

663
00:33:30,640 --> 00:33:35,060
당신이 지금하고 싶은 경우에, 죄송합니다, 이동
우리의 초기 문제에 백업합니다.

664
00:33:35,060 --> 00:33:37,780
의 코드 binary.c를 보자.

665
00:33:37,780 --> 00:33:40,870
따라서 반복적 인 버전을 구현
다음을 사용하여 이진 탐색

666
00:33:40,870 --> 00:33:42,420
함수 선언.

667
00:33:42,420 --> 00:33:44,550
>> 그리고 당신은 복사 할 필요가 없습니다
그 아래로 아직.

668
00:33:44,550 --> 00:33:49,470
실제로 열거야
최대 여기 binary.c.

669
00:33:49,470 --> 00:33:52,880
그래서 함수 선언이 있습니다
화면의 중앙에.

670
00:33:52,880 --> 00:33:57,570
그리고 당신은 내가 의사 코드를했다 볼 수 있습니다
내 양쪽에서, 그러나 거의 동일

671
00:33:57,570 --> 00:33:59,740
무엇을 우리가 쓰고,
당신을 위해 넣어.

672
00:33:59,740 --> 00:34:06,010
그래서 지금의 5 분 보자
이 기능을 코드에.

673
00:34:06,010 --> 00:34:08,199
>> 그리고 또, 당신은 질문이있는 경우에는,
손을 들어, 난 거 알려

674
00:34:08,199 --> 00:34:08,710
돌아올.

675
00:34:08,710 --> 00:34:09,800
>> 학생 : [청취].

676
00:34:09,800 --> 00:34:12,380
>> 제이슨 허쉬 호른 : 그래서 진했다
에서 검색 정의

677
00:34:12,380 --> 00:34:14,429
라인 (12)에, 맨.

678
00:34:14,429 --> 00:34:16,429
그게 내가 내 슬라이드있어거야.

679
00:34:16,429 --> 00:34:20,940
그리고이 모든 의사 코드 그냥
복사 및 슬라이드에서 붙여 넣기,

680
00:34:20,940 --> 00:34:22,190
의사 코드 슬라이드.

681
00:34:22,190 --> 00:35:22,830

682
00:35:22,830 --> 00:35:26,786
나는 아직도 들리지] 듣고 있지 않다.

683
00:35:26,786 --> 00:37:13,010

684
00:37:13,010 --> 00:37:15,820
>> 당신이 완료 그래서 경우
구현은, 나는 그것을 확인하고 싶습니다.

685
00:37:15,820 --> 00:37:19,410
나는 당신에게 helpers.h 파일을 이메일로 전송
이전에이 클래스의.

686
00:37:19,410 --> 00:37:22,360
그리고 그것은뿐만 아니라 온라인으로 사용할 수 있습니다
보는 사람들 다운로드

687
00:37:22,360 --> 00:37:24,750
이 섹션의 시간 지연.

688
00:37:24,750 --> 00:37:29,350
그리고 난 그냥 일반적인 분포를 사용
pset3의 코드.

689
00:37:29,350 --> 00:37:34,590
그래서 find.C, 내 helpers.h 파일을 사용했다
오히려 helpers.h 파일보다

690
00:37:34,590 --> 00:37:36,280
즉 분배 코드에 나와 있어요.

691
00:37:36,280 --> 00:37:39,310
>> 그리고 하나의 다른 변경을했다
오히려 단순히 호출하는 것보다 find.C

692
00:37:39,310 --> 00:37:42,770
검색, binary_search 호출합니다.

693
00:37:42,770 --> 00:37:49,080
그래서 당신은 당신의 코드를 테스트하려는 경우,
그 작업을 수행하는 방법 것을 알고 있습니다.

694
00:37:49,080 --> 00:37:52,530
사실, 우리는이 코드를 실행 할 수 있습니다 때
지금, 나는 단지의 사본을 만들어

695
00:37:52,530 --> 00:37:59,820
내 pset3 디렉토리, 다시, 스왑
다음 헬퍼 파일과 만든 그

696
00:37:59,820 --> 00:38:04,695
binary_search를 호출하는 find.C 변화
보다는 간단하게 검색 할 수 있습니다.

697
00:38:04,695 --> 00:40:08,620

698
00:40:08,620 --> 00:40:09,120
>> 제이슨 허쉬 호른 : 예.

699
00:40:09,120 --> 00:40:11,258
당신은 질문이 있다면?

700
00:40:11,258 --> 00:40:12,150
>> 학생 : 걱정하지 마라.

701
00:40:12,150 --> 00:40:12,600
>> 제이슨 허쉬 호른 : 걱정 마.

702
00:40:12,600 --> 00:40:13,370
글쎄, 지금 당장 시작하자.

703
00:40:13,370 --> 00:40:15,090
우리는 그룹으로이 코드를합니다.

704
00:40:15,090 --> 00:40:16,050
또 다른 메모.

705
00:40:16,050 --> 00:40:20,600
다시 말하지만, 이것은 쉽게 교환 할 수있다
문제 3 설정에 대한의.

706
00:40:20,600 --> 00:40:25,530
내 helpers.h 파일이있는, 오히려
helpers.h보다 우리가 제공하고,

707
00:40:25,530 --> 00:40:28,560
이진 검색, 거품을 선언
정렬 및 선택 정렬.

708
00:40:28,560 --> 00:40:37,400
그리고 find.c에 당신은 선에 알 수 있습니다,
무엇이 선 (68)은, 우리가 바이너리를 호출한다는 것입니다

709
00:40:37,400 --> 00:40:39,160
검색보다는 검색.

710
00:40:39,160 --> 00:40:42,930
그래서 다시 사용할 수있는 코드
온라인 또는 당신은 코드

711
00:40:42,930 --> 00:40:46,590
지금 만드는 것은 쉽게 교환 할 수있다
용의 p는 그것을 확인하기 위해 3을 설정합니다.

712
00:40:46,590 --> 00:40:50,620
>> 그러나 먼저, 이진 검색을 코딩 할 수 있습니다.

713
00:40:50,620 --> 00:40:53,690
우리의 함수 선언,
우리는 부울을 반환합니다.

714
00:40:53,690 --> 00:40:55,810
우리는 가치라는 정수를 취할.

715
00:40:55,810 --> 00:40:59,285
우리는라는 정수의 배열을
값, 우리는 할 수 없음이 걸릴

716
00:40:59,285 --> 00:41:00,850
어레이의 크기.

717
00:41:00,850 --> 00:41:05,640
바로 여기에 라인 10에, 나는이
샤프 stdbool.h 있습니다.

718
00:41:05,640 --> 00:41:07,360
그게 왜 거기에 사람이 알고 있나요?

719
00:41:07,360 --> 00:41:12,180

720
00:41:12,180 --> 00:41:16,600
그래서 코드의 라인은 무엇을 하는가?

721
00:41:16,600 --> 00:41:19,880
>> 학생 : 그것은 당신이 할 수 있습니다
부울 반환 형식을 사용합니다.

722
00:41:19,880 --> 00:41:20,350
>> 제이슨 허쉬 호른 : 그렇지.

723
00:41:20,350 --> 00:41:22,300
>> 학생 : 아니면 수있는 도서관
부울 반환 형식을 사용합니다.

724
00:41:22,300 --> 00:41:27,590
>> 제이슨 허쉬 호른 : 그래서 날카로운 포함
stdbool.h 라인은 나에게 약간의를 제공

725
00:41:27,590 --> 00:41:31,340
것들에 대한 정의와 선언
나는에 사용하도록 허용하고 있음

726
00:41:31,340 --> 00:41:32,400
이 라이브러리.

727
00:41:32,400 --> 00:41:36,570
그래서 그 사이에 있다는 것을 말하고있다
이 형식은 BOOL 불리는, 그것은 수있다

728
00:41:36,570 --> 00:41:37,750
참 또는 거짓.

729
00:41:37,750 --> 00:41:39,010
그래서 그 선이 무엇입니다.

730
00:41:39,010 --> 00:41:41,680
나는 그 라인을 가지고 있지 않은 경우, 나는 것
이 글을 쓰는위한 곤경에

731
00:41:41,680 --> 00:41:43,520
바로 여기, 부울, 바로 거기에 단어.

732
00:41:43,520 --> 00:41:44,140
정확히 맞아.

733
00:41:44,140 --> 00:41:46,430
그래서 나는이 코드에서 그 필요합니다.

734
00:41:46,430 --> 00:41:47,690
OK.

735
00:41:47,690 --> 00:41:51,860
그래서 이것은, 다시 반복입니다
버전이 아닌 재귀 하나.

736
00:41:51,860 --> 00:41:53,820
그래서 우리가 시작하자.

737
00:41:53,820 --> 00:41:56,200
>> 의이 처음부터 시작하자
의사 코드의 라인.

738
00:41:56,200 --> 00:41:58,770
그리고 바라건대, 우리는 것입니다 -
또는하지 희망.

739
00:41:58,770 --> 00:42:00,530
우리는 방 주위를 이동하는 것입니다.

740
00:42:00,530 --> 00:42:05,110
우리는 줄 단위로 갈거야, 그리고 도움이 될 것입니다
당신은 우리가 필요로하는 라인을 알아낼

741
00:42:05,110 --> 00:42:06,310
최초 작성.

742
00:42:06,310 --> 00:42:10,550
그래서 잠시리스트의 길이
0보다 크다.

743
00:42:10,550 --> 00:42:12,680
의 전면에서 시작하자.

744
00:42:12,680 --> 00:42:15,190
어떤 라인 내가 작성해야
여기에 코드?

745
00:42:15,190 --> 00:42:19,470
>> 학생 : 동안 괄호
n은 0보다 크다.

746
00:42:19,470 --> 00:42:21,900
>> 제이슨 허쉬 호른 : 동안
n은 0보다 크다.

747
00:42:21,900 --> 00:42:26,550
따라서 N은리스트의 사이즈
우리는 경우 확인하고 -

748
00:42:26,550 --> 00:42:26,800
>> [개재 목소리]

749
00:42:26,800 --> 00:42:27,660
>> 제이슨 허쉬 호른 - 네?

750
00:42:27,660 --> 00:42:29,360
>> 학생 : 우리는 어떻게 아십니까
N은리스트의 사이즈?

751
00:42:29,360 --> 00:42:29,690
>> 제이슨 허쉬 호른 : 죄송합니다.

752
00:42:29,690 --> 00:42:34,690
PSET 사양에 따라, 검색
및 종류, 당신이 작성해야하는 작용

753
00:42:34,690 --> 00:42:36,230
n은리스트의 크기입니다.

754
00:42:36,230 --> 00:42:37,710
나는 여기에 있다고 설명하는 것을 잊었다.

755
00:42:37,710 --> 00:42:41,310
그러나 예. N은 크기입니다
이 경우의 목록.

756
00:42:41,310 --> 00:42:44,740
그래서 동안 n은 0보다 크다.

757
00:42:44,740 --> 00:42:45,580
OK.

758
00:42:45,580 --> 00:42:50,090
즉, 약간의 문제가 될 수있다
하지만, 일을 계속합니다.

759
00:42:50,090 --> 00:42:54,510
우리는 알 것 때문에
이 전역 목록의 크기

760
00:42:54,510 --> 00:43:06,640
기능,하지만 우리가 시작 말
5 정수의 배열.

761
00:43:06,640 --> 00:43:08,950
그리고 우리는 통과하고 우리가했습니다
지금 좁혀

762
00:43:08,950 --> 00:43:10,310
2 정수의 배열.

763
00:43:10,310 --> 00:43:12,160
그 어떤 2​​의 정수이다?

764
00:43:12,160 --> 00:43:15,895
크기는 우리가 원하는 것을 지금 2
봐,하지만 그 어떤 2​​?

765
00:43:15,895 --> 00:43:17,720
즉, 그 질문을 이해합니까?

766
00:43:17,720 --> 00:43:18,020
>> OK.

767
00:43:18,020 --> 00:43:19,120
나는 다시 요청할 것입니다.

768
00:43:19,120 --> 00:43:26,640
그래서 우리는 5이 배열로 시작
정수, n은 바로, 5에 해당?

769
00:43:26,640 --> 00:43:28,050
우리는 여기를 통해 실행할 수 있습니다.

770
00:43:28,050 --> 00:43:31,560
우리는 아마 크기를 변경할 수 있습니다,
오른쪽 것들에 가서.

771
00:43:31,560 --> 00:43:32,700
이는 우리가 우리가하고 싶은 말은 무엇인가.

772
00:43:32,700 --> 00:43:34,150
우리는 검색하지 않으
전체 일 다시.

773
00:43:34,150 --> 00:43:35,480
그래서 우리는 2로 변경 말한다.

774
00:43:35,480 --> 00:43:36,970
우리는 이상한 반 목록을.

775
00:43:36,970 --> 00:43:38,800
그래서 그냥 2를 선택합니다.

776
00:43:38,800 --> 00:43:40,590
그래서 지금 N = 2.

777
00:43:40,590 --> 00:43:42,780
나는 가난한 사과
드라이 지우기 마커.

778
00:43:42,780 --> 00:43:43,080
오른쪽?

779
00:43:43,080 --> 00:43:45,670
그리고 우리는 목록을 검색하는
다시 크기 2의 목록.

780
00:43:45,670 --> 00:43:48,580
글쎄, 우리의 배열은 여전히​​ 5 사이즈입니다.

781
00:43:48,580 --> 00:43:51,920
우리는 우리는하고 싶은 말은
거기에 2 지점을 검색 할 수 있습니다.

782
00:43:51,920 --> 00:43:53,590
그래서 그 어떤 2​​ 점이 있습니까?

783
00:43:53,590 --> 00:43:57,640

784
00:43:57,640 --> 00:43:58,815
>> 그 의미가 있습니까?

785
00:43:58,815 --> 00:44:00,290
그들은 왼쪽 2 점이 있으신가요?

786
00:44:00,290 --> 00:44:01,940
그들은 바로이 점이 있습니까?

787
00:44:01,940 --> 00:44:03,540
그들은 중간 2 점이 있으신가요?

788
00:44:03,540 --> 00:44:06,350
우리는 우리의 문제를 세분화했지만 우리
실제로 모르는 어떤 부분의

789
00:44:06,350 --> 00:44:11,600
우리는 여전히보고있는 문제,
다만이 2 개의 변수를 필요로.

790
00:44:11,600 --> 00:44:16,450
그래서 우리는, 그 후에 조금 필요
n은 0보다 큰 동안.

791
00:44:16,450 --> 00:44:21,410
우리는 알 필요가 어디에
N은 우리의 실제적인 배열이다.

792
00:44:21,410 --> 00:44:26,660
>> 그래서 사람은 있습니까
이 라인으로 변경?

793
00:44:26,660 --> 00:44:27,970
이 라인의 대부분은
아무런 문제.

794
00:44:27,970 --> 00:44:29,170
다른 또 있나요?

795
00:44:29,170 --> 00:44:32,510
우리는에 N 뭔가 아웃 교환 할 수 있습니다
조금 더이 라인을 만들어?

796
00:44:32,510 --> 00:44:32,865
으흠?

797
00:44:32,865 --> 00:44:38,040
>> 학생 : 당신은 변수를 초기화 할 수 있습니다
다음 사용할 수 있습니다 N 길이가 같은

798
00:44:38,040 --> 00:44:39,600
나중에 기능?

799
00:44:39,600 --> 00:44:42,060
>> 제이슨 허쉬 호른 : 그래서 초기화
N에 가변 길이,

800
00:44:42,060 --> 00:44:42,900
우리는 나중에 사용?

801
00:44:42,900 --> 00:44:47,070
하지만 우리는 단지 길이 우리를 업데이트
여전히이 문제로 실행 어디

802
00:44:47,070 --> 00:44:51,180
우리의 문제의 길이를 줄이려고
그러나 우리는 실제로 어디에 있는지 결코

803
00:44:51,180 --> 00:44:52,510
그 길이에 매핑합니다.

804
00:44:52,510 --> 00:44:54,790
>> 학생 :이 발생하지 않을 것입니다
당신이 말을하는지 나중에 때, 왼쪽 검색

805
00:44:54,790 --> 00:44:55,746
바로 검색?

806
00:44:55,746 --> 00:44:57,640
당신은 다른에 가서
귀하의 지역 -

807
00:44:57,640 --> 00:44:59,110
>> 제이슨 허쉬 호른 : 우리는 갈거야
영역에, 우리가 어떻게 알 수 있습니까

808
00:44:59,110 --> 00:45:01,150
에 가서 어떤입니까?

809
00:45:01,150 --> 00:45:03,800
우리는 배열이있는 경우
N, 우리가 어떻게 알 수 있습니까 곳

810
00:45:03,800 --> 00:45:05,050
배열로 이동합니다.

811
00:45:05,050 --> 00:45:05,900
다시, 그래?

812
00:45:05,900 --> 00:45:07,507
>> 학생 : 당신이 있습니까, 같은 낮은
바인딩 및 상한 변수 나

813
00:45:07,507 --> 00:45:08,586
그런 식으로 뭔가?

814
00:45:08,586 --> 00:45:09,060
>> 제이슨 허쉬 호른 : OK.

815
00:45:09,060 --> 00:45:10,780
그래서 이것은 다른 생각입니다.

816
00:45:10,780 --> 00:45:13,490
오히려 단지를 추적하는 것보다
크기, 우리는 낮은 추적 및

817
00:45:13,490 --> 00:45:14,770
상한 변수입니다.

818
00:45:14,770 --> 00:45:17,840
그래서 우리가 어떻게에서 크기를 계산합니까
하한 및 상한값?

819
00:45:17,840 --> 00:45:18,520
>> [개재 목소리]

820
00:45:18,520 --> 00:45:19,710
>> 제이슨 허쉬 호른 : 빼기.

821
00:45:19,710 --> 00:45:23,650
또한 하부의 트랙을 유지
바인딩 상부 저희가 알게하는 바인딩,

822
00:45:23,650 --> 00:45:26,215
우리는이 두 가지를 찾고 있습니까?

823
00:45:26,215 --> 00:45:28,220
우리는 여기에 두 가지를 찾고 있습니까?

824
00:45:28,220 --> 00:45:29,540
우리는 중간에 두 가지를 찾고 있습니까?

825
00:45:29,540 --> 00:45:32,810
아마 중간에 두, 때문에
그러면, 실제로, 이진 검색이다.

826
00:45:32,810 --> 00:45:37,320
하지만 지금 우리는 크기를 얻을 수있을 것이다,
또한 어레이의 한계.

827
00:45:37,320 --> 00:45:40,020
본질적으로, 우리는 우리의 거대한이있는 경우
전화 번호부, 우리는 반으로 찢어.

828
00:45:40,020 --> 00:45:42,990
그 작은 곳에 우리는 지금 알고
전화 번호부입니다.

829
00:45:42,990 --> 00:45:45,260
그러나 우리는 실제로 리핑하지 않을
반 전화 번호부.

830
00:45:45,260 --> 00:45:48,570
우리는 여전히 알 필요가 어디에
우리의 문제의 새로운 범위이다.

831
00:45:48,570 --> 00:45:51,645
아무도 질문이 있습니까
에 대해?

832
00:45:51,645 --> 00:45:52,440
예?

833
00:45:52,440 --> 00:45:56,020
>> 학생 : 그것은을 만들어 일할 것
변수, 나는, 당신은 단지 이동하는 것이

834
00:45:56,020 --> 00:46:00,770
그 행 I의 위치
현재의 위치, 길이, N?

835
00:46:00,770 --> 00:46:01,710
>> 제이슨 허쉬 호른 : 그리고는 무엇인가?

836
00:46:01,710 --> 00:46:04,110
>> 학생 : 나는 일종의처럼되고 마음 -

837
00:46:04,110 --> 00:46:08,040
당신처럼 내가 할 초기화 한
배열의 중간 위치.

838
00:46:08,040 --> 00:46:12,540
그리고, 만일 위치의 값 난에
발견에 배열 중간

839
00:46:12,540 --> 00:46:17,870
당신이 필요로하는 값보다 작아야, 지금
배열의 길이가됩니다, 플러스

840
00:46:17,870 --> 00:46:19,215
I의 값은 2로 나눈 값.

841
00:46:19,215 --> 00:46:20,270
마찬가지로, 볼, 당신은 내가 교대 -

842
00:46:20,270 --> 00:46:20,770
>> 제이슨 허쉬 호른 : 오른쪽.

843
00:46:20,770 --> 00:46:21,165
>> 학생 : - 최대 -

844
00:46:21,165 --> 00:46:24,010
>> 제이슨 허쉬 호른 : 그래서 나는 거의입니다
작동 할 긍정적.

845
00:46:24,010 --> 00:46:26,800
하지만 요점은, 당신은 두 가지가 필요합니다
여기에 정보의 조각.

846
00:46:26,800 --> 00:46:30,050
당신은 시작과 끝 함께 할 수 있습니다
또는 당신은 그 크기와 함께 할, 수

847
00:46:30,050 --> 00:46:31,060
일부 마커.

848
00:46:31,060 --> 00:46:32,630
하지만 당신은 두 가지가 필요합니까
여기에 정보.

849
00:46:32,630 --> 00:46:34,160
당신은 하나에 의해 얻을 수 없습니다.

850
00:46:34,160 --> 00:46:35,830
그 의미가 있습니까?

851
00:46:35,830 --> 00:46:39,560
>> 그래서 우리는을 통해 갈 및입니다
우리가 할거야 [들림]

852
00:46:39,560 --> 00:46:41,330
일부 마커를 만들 수 있습니다.

853
00:46:41,330 --> 00:46:42,690
그래서 당신은 당신의 코드에서 뭘 쓰기?

854
00:46:42,690 --> 00:46:46,190
>> 학생 : 제가 말한 INT 바인딩
하나는 0과 동일하다.

855
00:46:46,190 --> 00:46:47,790
>> 제이슨 허쉬 호른 :의 호출하자
그 중간, 시작.

856
00:46:47,790 --> 00:46:49,140
>> 학생 : OK.

857
00:46:49,140 --> 00:46:50,590
>> 제이슨 허쉬 호른 : 그합니다
나에게 더 의미.

858
00:46:50,590 --> 00:46:51,670
그리고?

859
00:46:51,670 --> 00:46:54,340
>> 학생 : 나는 결말 중간, 내가 추측했다.

860
00:46:54,340 --> 00:46:55,870
>> 제이슨 허쉬 호른 : 종료 값 int.

861
00:46:55,870 --> 00:46:57,640
>> 학생 : 나는 추측, N - 1
또는 그런 일.

862
00:46:57,640 --> 00:46:59,100
마찬가지로, 마지막 요소.

863
00:46:59,100 --> 00:47:02,310
>> 제이슨 허쉬 호른 : 그래서 당신이 쓴, INT
등호 0, 세미콜론, 그리고 INT 시작

864
00:47:02,310 --> 00:47:04,320
결말은 N - 1, 세미콜론 같습니다.

865
00:47:04,320 --> 00:47:06,850
그래서 본질적으로, 우리는 무슨 일을하는지
여기서, 첫 번째 위치를 0.

866
00:47:06,850 --> 00:47:09,570
우리가 배열에 알고, 그들은 가지 마세요
N까지, 그들은 1 N 마이너스까지 이동합니다.

867
00:47:09,570 --> 00:47:11,110
그래서 우리는 우리의 배열의 일부 범위가있다.

868
00:47:11,110 --> 00:47:15,730
그리고 이러한 초기 경계는 될 일이
우리의 문제의 초기 경계입니다.

869
00:47:15,730 --> 00:47:16,640
OK.

870
00:47:16,640 --> 00:47:19,200
그래서 좋은 소리.

871
00:47:19,200 --> 00:47:22,380
그런 다음 우리는 다시이 라인에 가면 잠시
리스트의 길이가 0보다 크면

872
00:47:22,380 --> 00:47:24,752
무엇을, N 대신,해야
우리는 여기에 넣어?

873
00:47:24,752 --> 00:47:28,820
>> 학생 : 음의 시작을 종료 쓰기.

874
00:47:28,820 --> 00:47:34,780
>> 제이슨 허쉬 호른 : 마이너스를 종료하는 동안
시작은 0보다 크다?

875
00:47:34,780 --> 00:47:35,480
OK.

876
00:47:35,480 --> 00:47:37,730
그리고 우리는 우리가 원하는 경우, 할 수
확인이 조금 더 좋은, 무엇을

877
00:47:37,730 --> 00:47:38,980
그렇지 않으면 우리는 할 수 있습니까?

878
00:47:38,980 --> 00:47:41,650

879
00:47:41,650 --> 00:47:43,412
우리는 청소를 원하는 경우
최대 비트 코드?

880
00:47:43,412 --> 00:47:46,716

881
00:47:46,716 --> 00:47:48,180
우리는 어떻게 0을 제거 할 수 있습니까?

882
00:47:48,180 --> 00:47:51,560

883
00:47:51,560 --> 00:47:52,690
이것은 단지 스타일의 문제이다.

884
00:47:52,690 --> 00:47:53,690
그것은 지금 맞습니다.

885
00:47:53,690 --> 00:47:54,870
>> 학생 : 엔딩은하지 않습니다
동일한 시작?

886
00:47:54,870 --> 00:47:55,740
>> 제이슨 허쉬 호른 : 우리는 무엇을 할 수 있습니까?

887
00:47:55,740 --> 00:47:56,730
>> [개재 목소리]

888
00:47:56,730 --> 00:47:57,330
>> 학생 : 종료가 크다?

889
00:47:57,330 --> 00:47:57,720
>> 제이슨 허쉬 호른 : 네.

890
00:47:57,720 --> 00:48:01,110
종료하는 동안 우리는 단지 할 수있는
처음보다 더 크다.

891
00:48:01,110 --> 00:48:03,580
오른쪽.

892
00:48:03,580 --> 00:48:06,240
우리는 상대방에 시작 첨가
그 중, 우리는 0을 없앴습니다.

893
00:48:06,240 --> 00:48:08,000
그래서 이것은 단지 보인다
조금 청소기.

894
00:48:08,000 --> 00:48:08,990
OK.

895
00:48:08,990 --> 00:48:11,460
목록의 길이가 0 인 상태에 따라서, 우리는 썼다
즉, 종료하면서 큰

896
00:48:11,460 --> 00:48:12,240
시작보다.

897
00:48:12,240 --> 00:48:19,840
우리는 우리의 필요에 넣어거야
중괄호 다음 우선

898
00:48:19,840 --> 00:48:22,090
우리가 원하는 것은 볼 수 있습니다
작은 목록에서 그들.

899
00:48:22,090 --> 00:48:22,510
당신은?

900
00:48:22,510 --> 00:48:23,320
당신은 내게 줄 수있는 -에게

901
00:48:23,320 --> 00:48:26,460
>> 학생 : 만약 괄호
값 광장 브래킷 -

902
00:48:26,460 --> 00:48:30,450
>> 제이슨 허쉬 호른 : 괄호 경우
값 광장 브래킷.

903
00:48:30,450 --> 00:48:33,210
>> 학생 : 2로 나눈 기말.

904
00:48:33,210 --> 00:48:33,952
>> 제이슨 허쉬 호른 : 종료?

905
00:48:33,952 --> 00:48:35,280
>> 학생 : 나는 당신의 문제를 참조하십시오 -

906
00:48:35,280 --> 00:48:35,750
>> 제이슨 허쉬 호른 : OK.

907
00:48:35,750 --> 00:48:39,150
음, 중간보고.

908
00:48:39,150 --> 00:48:41,226
우리는 어떻게 중간이 무엇인지 알 수 있습니까?

909
00:48:41,226 --> 00:48:42,450
그래.

910
00:48:42,450 --> 00:48:43,070
그래서 내가 그 코드를 삭제 할 수 있습니다.

911
00:48:43,070 --> 00:48:46,360
우리는 어떻게 중간이 무엇인지 알 수 있습니까?

912
00:48:46,360 --> 00:48:48,003
아무것도, 당신은 시작이있을 때
그리고 말은, 당신은 어떻게 찾을 수 있습니까

913
00:48:48,003 --> 00:48:48,876
중간?

914
00:48:48,876 --> 00:48:49,590
>> 학생 : 당신은 평균.

915
00:48:49,590 --> 00:48:51,820
>> 학생 : 당신이 그들을 추가
함께 다음 -

916
00:48:51,820 --> 00:48:53,150
>> 제이슨 허쉬 호른 :에 추가
함께하고?

917
00:48:53,150 --> 00:48:54,090
>> 학생 : 그리고 당신은 평균.

918
00:48:54,090 --> 00:48:55,050
2로 나눈다.

919
00:48:55,050 --> 00:48:56,500
>> 제이슨 허쉬 호른 :에 추가
함께 2로 나눈다.

920
00:48:56,500 --> 00:48:59,400
그래서 INT 중간 같음?

921
00:48:59,400 --> 00:49:01,120
톰, 당신은 내게 줄 수 있습니까?

922
00:49:01,120 --> 00:49:03,550
>> 학생 : 기초 플러스 끝 -

923
00:49:03,550 --> 00:49:04,950
>> 제이슨 허쉬 호른 : 시작
플러스 끝.

924
00:49:04,950 --> 00:49:06,880
>> 학생 : 모든, 브라켓, 2로 나눈.

925
00:49:06,880 --> 00:49:10,940
>> 제이슨 허쉬 호른 : 모든 괄호에,
2로 나눈 값.

926
00:49:10,940 --> 00:49:16,300
그래서 나에게 중간을 제공합니다
아무것도, 수정?

927
00:49:16,300 --> 00:49:18,980
>> 학생 : 당신은 또한 그것을 반올림해야합니다.

928
00:49:18,980 --> 00:49:19,990
>> 제이슨 허쉬 호른 : 당신이 할
말은 그것을 반올림해야합니까?

929
00:49:19,990 --> 00:49:20,400
>> [개재 목소리]

930
00:49:20,400 --> 00:49:24,520
>> 학생 : 때문에 홀수의 경우
수는 그 때처럼 -

931
00:49:24,520 --> 00:49:25,440
>> 제이슨 허쉬 호른 : 음, OK.

932
00:49:25,440 --> 00:49:26,360
그래서 그것을 반올림 수 있습니다.

933
00:49:26,360 --> 00:49:33,350
이 홀수, 5의 경우, 나는 할 수있다
중앙에서 멀어 촬영 1.

934
00:49:33,350 --> 00:49:35,665
또는 그것을 짝수라면, 오히려
그것은 더 나은 경우입니다.

935
00:49:35,665 --> 00:49:39,600
이 4의 경우, 우리는 4가, 내가 걸릴 수 있습니다
최초의 "중간", 인용, 인용을 끝내 나

936
00:49:39,600 --> 00:49:41,760
두 번째 "중간"한.

937
00:49:41,760 --> 00:49:46,390
하나는 이진 검색을 위해 일 것입니다,
그래서 실제로 반올림 할 필요가 없습니다.

938
00:49:46,390 --> 00:49:48,640
그러나 한 가지의 I가
이 라인에서 볼 필요가있다.

939
00:49:48,640 --> 00:49:50,530
우리는 아직 실현되지 않을 수도 있습니다
그러나 우리는 다시 돌아올 수 있습니다.

940
00:49:50,530 --> 00:49:53,200
이 라인 사실 때문에 여전히
한 가지가 필요합니다.

941
00:49:53,200 --> 00:49:55,990
>> 그러나 지금까지, 우리는 서면으로 작성했습니다
네 줄의 코드.

942
00:49:55,990 --> 00:49:58,120
우리는 우리의 시작을 가지고있어
마커를 종료.

943
00:49:58,120 --> 00:50:01,320
우리는 매핑 우리의 while 루프를 가지고
에 직접적으로 우리의 의사에.

944
00:50:01,320 --> 00:50:05,790
우리는 매핑 중간보고있는
직접 우리의 의사 상.

945
00:50:05,790 --> 00:50:09,070
나는이 중간에 간다 말을
목록의 코드 행.

946
00:50:09,070 --> 00:50:11,560
그리고, 한 번 우리의 중앙으로 이동
목록, 우리가해야 할 다음 일은

947
00:50:11,560 --> 00:50:14,880
우리의 가치는 거기에 있는지 확인한다
의사는 우리가 이전에 썼다.

948
00:50:14,880 --> 00:50:17,100
>> 어떻게 우리가 확인하는 경우에 우리의 가치
목록의 중간에있다?

949
00:50:17,100 --> 00:50:17,300
당신.

950
00:50:17,300 --> 00:50:18,511
왜 당신이하지 않는다?

951
00:50:18,511 --> 00:50:23,070
>> 학생 : 우리의 가치의 인 경우
중간에 동일합니다

952
00:50:23,070 --> 00:50:24,592
우리는 설정대로 -

953
00:50:24,592 --> 00:50:26,190
나는 동일한 동일한 의미 -

954
00:50:26,190 --> 00:50:26,690
>> 제이슨 허쉬 호른 : 그것은 -

955
00:50:26,690 --> 00:50:27,940
OK.

956
00:50:27,940 --> 00:50:30,080

957
00:50:30,080 --> 00:50:32,170
>> 학생 : 잘 모르겠어요 무엇
변수 우리가 찾고

958
00:50:32,170 --> 00:50:32,850
에 대한 생각, 때문에 -

959
00:50:32,850 --> 00:50:33,330
>> [개재 목소리]

960
00:50:33,330 --> 00:50:34,520
>> 학생 : [청취].

961
00:50:34,520 --> 00:50:35,060
>> 제이슨 허쉬 호른 : 그렇지.

962
00:50:35,060 --> 00:50:37,260
함수 선언 당,
우리는 값을 찾고 있습니다.

963
00:50:37,260 --> 00:50:39,760
그래서 우리는 값을 검색하는
값의 배열.

964
00:50:39,760 --> 00:50:41,080
그래서 당신은 정확히 맞아.

965
00:50:41,080 --> 00:50:45,040
당신은 할 것입니다, 만약 열린 괄호 값 브래킷
중간 브라켓 같음 폐쇄

966
00:50:45,040 --> 00:50:49,930
내부가 값과 동일하고,
우리가 어떻게해야합니까?

967
00:50:49,930 --> 00:50:51,230
만약에 우리의 가치의가 무엇
우리는 어떻게해야합니까?에게

968
00:50:51,230 --> 00:50:51,420
>> [개재 목소리]

969
00:50:51,420 --> 00:50:52,160
>> 학생 : 0을 반환.

970
00:50:52,160 --> 00:50:53,070
>> 제이슨 허쉬 호른 : true를 돌려줍니다.

971
00:50:53,070 --> 00:50:54,790
>> 학생 : true를 돌려줍니다.

972
00:50:54,790 --> 00:50:57,856
>> 제이슨 허쉬 호른 : 마이클,
이 라인은 무엇을 하는가?

973
00:50:57,856 --> 00:51:01,105
>> 학생 : [청취] 프로그램이 실행 된
그 과정은, 그리고 그 이상이며,

974
00:51:01,105 --> 00:51:01,920
당신은 당신이해야 할 일을했습니다?

975
00:51:01,920 --> 00:51:03,030
>> 제이슨 허쉬 호른 : 프로그램 또는 무엇?

976
00:51:03,030 --> 00:51:03,700
이 경우?

977
00:51:03,700 --> 00:51:04,210
>> 학생 : 기능.

978
00:51:04,210 --> 00:51:05,170
>> 제이슨 허쉬 호른 : 기능.

979
00:51:05,170 --> 00:51:08,420
그래서,라고 어떤으로 돌아갑니다
그것과는 사실, 그것을 값을 제공합니다.

980
00:51:08,420 --> 00:51:09,890
정확히 맞아.

981
00:51:09,890 --> 00:51:10,170
메인.

982
00:51:10,170 --> 00:51:12,035
반환 형식은 무엇입니까
주의, 마이클?

983
00:51:12,035 --> 00:51:16,480

984
00:51:16,480 --> 00:51:17,150
>> 학생 : 중간, 정수?

985
00:51:17,150 --> 00:51:18,080
>> 제이슨 허쉬 호른 : INT, 정확하게.

986
00:51:18,080 --> 00:51:18,680
정수입니다.

987
00:51:18,680 --> 00:51:20,980
즉, 확인 그냥 질문했다
너희들은 그 위에 있었다.

988
00:51:20,980 --> 00:51:24,250
보통 경우, 무엇을 반환하지
모든 것이 잘 작동된다?

989
00:51:24,250 --> 00:51:24,520
>> 학생 : 제로.

990
00:51:24,520 --> 00:51:24,820
>> 제이슨 허쉬 호른 : 제로.

991
00:51:24,820 --> 00:51:25,430
정확히 맞아.

992
00:51:25,430 --> 00:51:28,790
>> 학생이 그냥 true를 반환하면,
제공되는 관련 정보가 없습니다

993
00:51:28,790 --> 00:51:30,675
에 대해 무엇을 -

994
00:51:30,675 --> 00:51:34,040
오, 이건 그냥하는 말이되는 그
값은 배열의 내부입니다.

995
00:51:34,040 --> 00:51:35,350
>> 제이슨 허쉬 호른 : 그렇지.

996
00:51:35,350 --> 00:51:38,080
이 프로그램은 정보를 제공하지 않습니다
값이 정확히 어디의.

997
00:51:38,080 --> 00:51:41,850
그것은 단지 예, 우리가 발견 한, 말하는 것
그것은, 또는 아니오, 우리는 그것을 찾을 수 없습니다.

998
00:51:41,850 --> 00:51:42,990
그래서 번호를 발견하는 경우, true를 돌려줍니다.

999
00:51:42,990 --> 00:51:45,500
음, 사실 우리는 단지 않았다 정말
빨리 코드의 한 라인.

1000
00:51:45,500 --> 00:51:47,500
그래서 의사의 라인을 이동합니다.

1001
00:51:47,500 --> 00:51:50,045
>> 학생 : 우리는 필요로하지 말라
배열을 변경하려면?

1002
00:51:50,045 --> 00:51:52,830
그것은 바로, 값이 아닌 값이어야합니다?

1003
00:51:52,830 --> 00:51:53,430
>> 제이슨 허쉬 호른 : 죄송합니다.

1004
00:51:53,430 --> 00:51:54,010
감사합니다.

1005
00:51:54,010 --> 00:51:54,800
>> 학생 : 네.

1006
00:51:54,800 --> 00:51:55,850
>> 제이슨 허쉬 호른 :이 줄
값이어야한다.

1007
00:51:55,850 --> 00:51:57,150
정확히 맞아.

1008
00:51:57,150 --> 00:51:57,920
OK.

1009
00:51:57,920 --> 00:51:59,170
그래서 우리는 중간 목록을 살펴 보았다.

1010
00:51:59,170 --> 00:52:00,790
수 있습니다 반환 true의 경우.

1011
00:52:00,790 --> 00:52:04,470
경우에, 우리의 의사와에 계속
중간 큰, 검색 떠났다.

1012
00:52:04,470 --> 00:52:09,640
그래서 만약 내가 여기에 있었다 수
높은 검색 떠났다.

1013
00:52:09,640 --> 00:52:12,700

1014
00:52:12,700 --> 00:52:14,462
콘스탄틴, 당신은 줄 수
나 코드 행?

1015
00:52:14,462 --> 00:52:17,240

1016
00:52:17,240 --> 00:52:23,520
>> 학생 : 중간의 경우 값 -

1017
00:52:23,520 --> 00:52:24,890
>> 제이슨 허쉬 호른 : 그래서 값이있는 경우 -

1018
00:52:24,890 --> 00:52:28,890
열린 괄호는 괄호 값 경우
중간 대괄호 -

1019
00:52:28,890 --> 00:52:31,500
>> 학생 : 값보다 작은가요?

1020
00:52:31,500 --> 00:52:32,760
>> 제이슨 허쉬 호른은 : 이하입니다.

1021
00:52:32,760 --> 00:52:33,800
>> 학생 : 값보다 작.

1022
00:52:33,800 --> 00:52:34,060
>> 제이슨 허쉬 호른 : 값.

1023
00:52:34,060 --> 00:52:35,310
음, 사실, 당신이 원하는
수 있는지 확인 -

1024
00:52:35,310 --> 00:52:38,310

1025
00:52:38,310 --> 00:52:38,490
미안 해요.

1026
00:52:38,490 --> 00:52:39,140
이것은 약간의 혼란이다.

1027
00:52:39,140 --> 00:52:43,920
하지만 다른 경우의 수
목록의 중간 크다.

1028
00:52:43,920 --> 00:52:45,170
>> 학생 : 아, 그렇군요.

1029
00:52:45,170 --> 00:52:49,800

1030
00:52:49,800 --> 00:52:50,410
>> 제이슨 허쉬 호른 : 그 변경됩니다.

1031
00:52:50,410 --> 00:52:55,060
중간 높은 다른 경우, 우리
OK, 왼쪽 검색 할?

1032
00:52:55,060 --> 00:52:57,310
그리고 우리는 안에 무엇을해야합니까
이 조건의 경우?

1033
00:52:57,310 --> 00:53:03,660

1034
00:53:03,660 --> 00:53:07,510
>> 학생 : 나는에 작은 변화를 만들 수있다
경우 조건은, 다른으로 변경?

1035
00:53:07,510 --> 00:53:08,380
>> 제이슨 허쉬 호른 : 만약 그렇지?

1036
00:53:08,380 --> 00:53:09,270
OK.

1037
00:53:09,270 --> 00:53:12,840
따라서이 코드가 실행됩니다
같은 약.

1038
00:53:12,840 --> 00:53:18,620
그러나 다른, 경우에 사용하는 방법에 대한 좋은 점
, 경우 경우 또는 다른 다른 경우, 다른, 경우

1039
00:53:18,620 --> 00:53:22,320
그 중 하나가에가는 것을 의미한다
확인하지 그 중 세 가지,

1040
00:53:22,320 --> 00:53:23,290
잠재적으로.

1041
00:53:23,290 --> 00:53:25,530
그리고 그것이 조금 있습니다
의 컴퓨터에 더 좋은

1042
00:53:25,530 --> 00:53:26,670
프로그램을 실행.

1043
00:53:26,670 --> 00:53:27,620
>> 그래서 [? 콘스탄틴,?]

1044
00:53:27,620 --> 00:53:31,330
우리는 값이 다른 경우,이 라인 안쪽에있어
브라켓 중간 대괄호

1045
00:53:31,330 --> 00:53:32,260
값보다 더 크다.

1046
00:53:32,260 --> 00:53:33,150
우리는 무엇을해야합니까?

1047
00:53:33,150 --> 00:53:33,970
우리는 왼쪽을 검색해야합니다.

1048
00:53:33,970 --> 00:53:35,220
우리가 어떻게해야합니까?

1049
00:53:35,220 --> 00:53:46,960

1050
00:53:46,960 --> 00:53:48,720
나는 당신에게 시작을 줄거야.

1051
00:53:48,720 --> 00:53:52,210
>> 우리는 호출이 두 가지가
시작과 끝.

1052
00:53:52,210 --> 00:53:57,340
그래서 무슨 일이 일어날 필요
처음으로?

1053
00:53:57,340 --> 00:53:59,640
당신의 왼쪽을 검색하려면
목록, 우리는 우리의 현재 시작을 얻을.

1054
00:53:59,640 --> 00:54:01,080
우리는 무엇을해야합니까?

1055
00:54:01,080 --> 00:54:04,220
>> 학생 : 우리는 시작을 설정
중간 플러스 1.

1056
00:54:04,220 --> 00:54:05,120
>> 제이슨 허쉬 호른 : 그래서 우리가 야하는 경우
왼쪽을 찾고?

1057
00:54:05,120 --> 00:54:06,250
>> 학생 : 죄송합니다, 중간 마이너스 -

1058
00:54:06,250 --> 00:54:11,310
그래서 결말은 중간 것
- 1과 시작 -

1059
00:54:11,310 --> 00:54:12,450
>> 제이슨 허쉬 호른 : 그리고 무엇
시작됩니까?

1060
00:54:12,450 --> 00:54:13,210
>> 학생 : 그것은 동일하게 유지됩니다.

1061
00:54:13,210 --> 00:54:14,120
>> 제이슨 허쉬 호른 : 그래서
의미는 동일하게 유지됩니다.

1062
00:54:14,120 --> 00:54:16,040
우리는 왼쪽을 검색하는 경우, 우린
같은 시작을 사용하여 -

1063
00:54:16,040 --> 00:54:16,860
정확히 맞아.

1064
00:54:16,860 --> 00:54:17,870
그리고 끝?

1065
00:54:17,870 --> 00:54:19,390
죄송합니다, 어떻게합니까
다시 같은 결말?

1066
00:54:19,390 --> 00:54:20,750
>> 학생 : 중동 - 1.

1067
00:54:20,750 --> 00:54:21,620
>> 제이슨 허쉬 호른 : 중간 - 1.

1068
00:54:21,620 --> 00:54:23,470
자, 왜 - 1, 중간이 아니라?

1069
00:54:23,470 --> 00:54:32,870

1070
00:54:32,870 --> 00:54:35,570
>> 학생 : 중간 벗어
우리가했기 때문에, 이미 그림

1071
00:54:35,570 --> 00:54:36,700
그것이 밖으로되는지 점검?

1072
00:54:36,700 --> 00:54:37,630
>> 제이슨 허쉬 호른 : 때문입니다
정확히 맞아.

1073
00:54:37,630 --> 00:54:38,580
중간 사진의 부족합니다.

1074
00:54:38,580 --> 00:54:39,800
우리는 이미 중간 점검.

1075
00:54:39,800 --> 00:54:44,730
그래서 우리는 "중간"견적을 원하지 않는
끝 맺다,에있을 계속

1076
00:54:44,730 --> 00:54:46,110
우리가 찾고있는 것을 배열입니다.

1077
00:54:46,110 --> 00:54:47,670
그래서이 환상적이다.

1078
00:54:47,670 --> 00:54:50,670
>> 다른 값 브라켓 중간 큰 경우
값이 같음을 종료 이상

1079
00:54:50,670 --> 00:54:51,920
중간 - 1.

1080
00:54:51,920 --> 00:54:55,060

1081
00:54:55,060 --> 00:54:57,340
제프, 어떤이 마지막 줄에 대해?

1082
00:54:57,340 --> 00:54:58,590
>> 학생 : 그렇지.

1083
00:54:58,590 --> 00:55:02,486

1084
00:55:02,486 --> 00:55:06,000
값의 중간 값보다 작?

1085
00:55:06,000 --> 00:55:07,570
>> 제이슨 허쉬 호른 : 우리는거야
당신은 다른 저를주는거야.

1086
00:55:07,570 --> 00:55:09,310
당신이 저를 포기하지 않는 경우에 따라서 -

1087
00:55:09,310 --> 00:55:12,270
>> 학생 : 그럼 시작
중간에 1을 더한 것입니다.

1088
00:55:12,270 --> 00:55:16,100

1089
00:55:16,100 --> 00:55:19,070
>> 제이슨 허쉬 호른 : 시작 같음
중간에 1을 더한, 다시 대한 동일

1090
00:55:19,070 --> 00:55:20,820
이유가 콘스탄틴
이전에 우리를했다.

1091
00:55:20,820 --> 00:55:24,280
그리고 마지막에 누가하지 않았습니다
아직 저 한 줄의 코드?

1092
00:55:24,280 --> 00:55:26,600
거짓, Aleha을 반환 무엇
우리는 여기에 씁니까?

1093
00:55:26,600 --> 00:55:28,590
>> 학생 : false를 반환합니다.

1094
00:55:28,590 --> 00:55:29,320
>> 제이슨 허쉬 호른 : false를 반환합니다.

1095
00:55:29,320 --> 00:55:33,340
그리고 우리는 그렇게 할 필요가 있기 때문에 만약에 우리
그것을 발견하지 않습니다, 우리는 우리가 말을 할 필요가

1096
00:55:33,340 --> 00:55:34,080
를 찾을 수 없습니다.

1097
00:55:34,080 --> 00:55:36,270
그리고 우리는 우리가 반환하는 것입니다 말했다
부울, 그래서 우리는 확실히 반환해야

1098
00:55:36,270 --> 00:55:38,150
부울 곳.

1099
00:55:38,150 --> 00:55:42,590
>> 그래서이 코드를 실행 할 수 있습니다.

1100
00:55:42,590 --> 00:55:44,520
사실에 갈거야 -

1101
00:55:44,520 --> 00:55:45,930
그래서 우리는 터미널에 있어요.

1102
00:55:45,930 --> 00:55:47,230
우리는 우리의 창을 취소합니다.

1103
00:55:47,230 --> 00:55:49,270
의 모든를 만들자.

1104
00:55:49,270 --> 00:55:50,340
우리는 하나의 오류가 거기에 있습니다.

1105
00:55:50,340 --> 00:55:54,280
예상 라인 (15)에 오류가 있습니다
끝에 세미콜론

1106
00:55:54,280 --> 00:55:54,890
선언.

1107
00:55:54,890 --> 00:55:56,454
그래서 내가 무엇을 잊지 않았다?

1108
00:55:56,454 --> 00:55:57,230
>> 학생 : 세미콜론.

1109
00:55:57,230 --> 00:56:00,200
>> 제이슨 허쉬 호른 : 세미콜론
여기까지.

1110
00:56:00,200 --> 00:56:00,950
그 톰의 코드라고 생각.

1111
00:56:00,950 --> 00:56:01,870
그래서 톰, [들림].

1112
00:56:01,870 --> 00:56:03,120
농담.

1113
00:56:03,120 --> 00:56:05,010

1114
00:56:05,010 --> 00:56:07,310
의 모든 다시 확인 해 보자.

1115
00:56:07,310 --> 00:56:10,180
>> 학생 : 어떤 보관 용 디렉토리
우리는 이것에해야 하는가?

1116
00:56:10,180 --> 00:56:11,345
>> 제이슨 허쉬 호른 : 그래서 당신이 할 수있는
다만이 비트에 대한 감시.

1117
00:56:11,345 --> 00:56:16,380
그러나 다시, 당신이 이동하려는 경우
시도하십시오 pset3 디렉토리에 코드

1118
00:56:16,380 --> 00:56:17,050
그것을 밖으로, 내가 무슨 짓을했는지.

1119
00:56:17,050 --> 00:56:18,600
여기에서 알 수있는 경우 -
죄송합니다, 좋은 질문입니다.

1120
00:56:18,600 --> 00:56:19,460
>> [? LS,?]

1121
00:56:19,460 --> 00:56:24,700
여기에서있는 find.c 코드
이번 주 배포판 코드에서.

1122
00:56:24,700 --> 00:56:26,300
나는 helpers.h있다.

1123
00:56:26,300 --> 00:56:30,010
나는 실제로 만들기 파일이
이러한 새를 포함하는 비트를 편집

1124
00:56:30,010 --> 00:56:30,710
우리가 작성하는 파일입니다.

1125
00:56:30,710 --> 00:56:34,120
그 모든 코드를 사용할 수없는 것입니다
분배 코드 만 새

1126
00:56:34,120 --> 00:56:39,510
파일을 새 helpers.h 파일 것
다운로드 온라인으로 사용할 수 있습니다.

1127
00:56:39,510 --> 00:56:41,800
다시, 그래서 그것들은이 아르
여분의 코드는 우리가.

1128
00:56:41,800 --> 00:56:46,130
>> 그래서 모두 확인이 줄에, 찾을 수 있습니다
이진, 거품 선택 - 만든다

1129
00:56:46,130 --> 00:56:50,930
모두 3 개과에 컴파일
이 실행 코드를 찾을 수 있습니다.

1130
00:56:50,930 --> 00:56:54,090
그래서 일반적으로, 우리는 원하지 않는
바로 check50에에.

1131
00:56:54,090 --> 00:56:57,580
우리는 우리 자신에 대한 몇 가지 테스트를 실행합니다.

1132
00:56:57,580 --> 00:57:11,750
그러나 다만 우리가이 비트를 촉진 할 수 있습니다
check50 2013 pset3.find이 전달됩니다

1133
00:57:11,750 --> 00:57:14,630
나의 나쁜 - helpers.c에서.

1134
00:57:14,630 --> 00:57:16,050
>> 바로 지금이 없습니다.

1135
00:57:16,050 --> 00:57:20,670
그래서 우리는 실제로거야
실제의 코드를 실행합니다.

1136
00:57:20,670 --> 00:57:23,570
Usage.find /, 당신은 그게 무슨 뜻인지 알아?

1137
00:57:23,570 --> 00:57:25,970
>> 학생 : 당신은 두 번째 필요
그것에 명령 행.

1138
00:57:25,970 --> 00:57:26,980
>> 제이슨 허쉬 호른 : 나는 필요
두 번째 명령 행.

1139
00:57:26,980 --> 00:57:30,640
그리고 사양에 따라, 나는 필요
우리가 원하는 정보를 입력합니다.

1140
00:57:30,640 --> 00:57:33,750
그래서 42에 대해 살펴 보자.

1141
00:57:33,750 --> 00:57:37,030
우리는 순위를 유지하기 때문에 다음
아직 분류 기능을 작성하지 않았습니다 -

1142
00:57:37,030 --> 00:57:41,830
42, 43, 44.

1143
00:57:41,830 --> 00:57:46,240
>> 및 제어 D는 찾을 수 없습니다
건초 더미에서 바늘.

1144
00:57:46,240 --> 00:57:46,505
그게 나쁘다.

1145
00:57:46,505 --> 00:57:47,200
그것은 확실히있다.

1146
00:57:47,200 --> 00:57:48,090
의 다른 무언가를 시도 할 수 있습니다.

1147
00:57:48,090 --> 00:57:49,860
내가 넣어 때문에 아마의
처음에.

1148
00:57:49,860 --> 00:57:54,490
>> 의 41, 42, 43를 보자.

1149
00:57:54,490 --> 00:57:55,012
거기 우리는 간다.

1150
00:57:55,012 --> 00:57:56,400
그것을 발견했다.

1151
00:57:56,400 --> 00:58:00,040
그냥, 지금은 말을 넣어 보자
그래서 우리는 철저하게 할 수있다 -

1152
00:58:00,040 --> 00:58:03,580
40, 41, 42.

1153
00:58:03,580 --> 00:58:05,760
바늘을 찾을 수 없습니다.

1154
00:58:05,760 --> 00:58:07,550
그래서이 이전을 언급했다.

1155
00:58:07,550 --> 00:58:08,980
불행하게도,이 알고
일어날.

1156
00:58:08,980 --> 00:58:11,490
>> 그러나 교육적인 목적을 위해,
그것을 탐구하는 것이 좋다.

1157
00:58:11,490 --> 00:58:12,990
그것은 작동하지 않습니다.

1158
00:58:12,990 --> 00:58:16,020
어떤 이유로, 그것을 찾을 수 없습니다.

1159
00:58:16,020 --> 00:58:18,970
우리는 거기에서 무엇을 알고 있지만,
우리는 그것을 찾을 수 없습니다.

1160
00:58:18,970 --> 00:58:24,140
그래서 우리가 할 수있는 한 가지를 통해 이동합니다
GDB는 그것을 찾을 수 있지만 사람을 수행하는

1161
00:58:24,140 --> 00:58:27,850
GDB를 사용하지 않고,이
우리가 망쳐 곳의 의미?

1162
00:58:27,850 --> 00:58:28,480
[? 마두? ?]

1163
00:58:28,480 --> 00:58:30,960
>> 학생 : 나는 그것이 종료 될 수 있습니다 때 생각
처음으로 동일하며, 그것의 정보

1164
00:58:30,960 --> 00:58:33,090
단지 하나의 요소 목록을 표시합니다.

1165
00:58:33,090 --> 00:58:35,560
다음은 대신이를 무시
의 사실을 확인합니다.

1166
00:58:35,560 --> 00:58:36,940
>> 제이슨 허쉬 호른 : 때문입니다
정확히 맞아.

1167
00:58:36,940 --> 00:58:41,110
결말은 처음과 같을 때, 우리가 할
아직도 우리의 목록에서 요소가?

1168
00:58:41,110 --> 00:58:42,480
>> 학생 : 예.

1169
00:58:42,480 --> 00:58:45,450
>> 제이슨 허쉬 호른 : 네, 사실, 우리
오직 하나의 요소가있다.

1170
00:58:45,450 --> 00:58:50,500
그리고 그 가능성이 가장 높은 때 발생합니다,
우리가 테스트 코드마다, 우리는에있다

1171
00:58:50,500 --> 00:58:54,640
건초 더미의 또는 전면
건초 더미의 끝입니다.

1172
00:58:54,640 --> 00:58:56,000
여기서 시작과 그의
결말은 동일가는

1173
00:58:56,000 --> 00:58:57,820
이진 검색 한.

1174
00:58:57,820 --> 00:59:01,440
그래서 그 두 가지의 경우에 작동하지 않았다,
종료하기 때문에이 처음으로 동일했다.

1175
00:59:01,440 --> 00:59:06,030
>> 그러나 종료하는 경우는, 시작과 동일
이 while 루프가 실행 하는가?

1176
00:59:06,030 --> 00:59:06,390
그것은하지 않습니다.

1177
00:59:06,390 --> 00:59:08,660
그리고 우리는 확인할 수 있었다
그 다시 GDB를 통해.

1178
00:59:08,660 --> 00:59:14,000
그렇다면 우리는이 코드를 수정할 수 있기 때문에
종료 상태가 동일한 경우

1179
00:59:14,000 --> 00:59:16,070
시작, 우리는 또한이 원하는
루프가 실행하는 동안.

1180
00:59:16,070 --> 00:59:18,620
>> 그래서 우리는 18 라인 무엇을 수정 할 수 있습니까?

1181
00:59:18,620 --> 00:59:21,060
>> 학생 : [청취] 큰
거나 같음.

1182
00:59:21,060 --> 00:59:21,700
>> 제이슨 허쉬 호른 : 맞아 맞아.

1183
00:59:21,700 --> 00:59:24,600
엔딩보다 큰 반면
또는 시작과 동일.

1184
00:59:24,600 --> 00:59:27,300
그래서 지금, 우리는 그것을 얻을 수 있는지 확인
끝 모서리 케이스.

1185
00:59:27,300 --> 00:59:27,870
그리고 보자.

1186
00:59:27,870 --> 00:59:29,560
의이 한 번 더 실행할 수 있습니다.

1187
00:59:29,560 --> 00:59:31,266
>> 의 모두를 만들어 보자.

1188
00:59:31,266 --> 00:59:33,910
다시 말하지만, 당신은해야 할 것이다 단지
여기에 함께 따라.

1189
00:59:33,910 --> 00:59:36,280
41이 시간을 찾을 수 있습니다.

1190
00:59:36,280 --> 00:59:37,360
그냥 일관성 유지.

1191
00:59:37,360 --> 00:59:38,210
>> (42)를 찾을 수 있습니다.

1192
00:59:38,210 --> 00:59:38,930
의 처음에 그것을 넣어 보자 -

1193
00:59:38,930 --> 00:59:41,630
42, 43, 44.

1194
00:59:41,630 --> 00:59:42,860
우리는 그것을 발견했다.

1195
00:59:42,860 --> 00:59:47,710
그래서 참으로 변화했다
우리는 만들 필요가 있었다.

1196
00:59:47,710 --> 00:59:51,090
>> 즉, 우리는 코딩을 많이했다
다만, 이진 검색을했다.

1197
00:59:51,090 --> 00:59:55,760
전에 누군가가 질문이 있습니까
나는 우리가 쓴 라인으로 이동

1198
00:59:55,760 --> 00:59:58,750
이진 검색 또는 우리가 어떻게 생각
우리가 알아낼 않았다 무엇인지?

1199
00:59:58,750 --> 01:00:01,900

1200
01:00:01,900 --> 01:00:06,270
우리가 이동하기 전에, 나는 또한 지적하고 싶어요
이 전반적으로 중, 우리는 매핑

1201
01:00:06,270 --> 01:00:09,300
우리의 의사 코드 하나
우리의 코드 상에 하나.

1202
01:00:09,300 --> 01:00:11,550
>> 우리는 까다로운 일이 있었나요
로 파악하는

1203
01:00:11,550 --> 01:00:12,890
시작과 끝.

1204
01:00:12,890 --> 01:00:17,380
하지만 당신은 당신이 그것을 눈치 채지 못했다
꽤 많이 쓴 것

1205
01:00:17,380 --> 01:00:20,740
동일한 코드를 저장하기
그 위에 두 줄.

1206
01:00:20,740 --> 01:00:23,380
그리고 당신은 실현했을 때
당신이 검사하고 경우에 그것을 만든 그

1207
01:00:23,380 --> 01:00:24,840
당신은 다른 뭔가가 필요합니다.

1208
01:00:24,840 --> 01:00:28,510
당신이 따랐다 그래서도 우리
라인에 의사 코드 라인, 당신은했습니다 것

1209
01:00:28,510 --> 01:00:31,130
두 줄 그러나 모든 받고
여러분이 작성하는 데 필요한 코드입니다.

1210
01:00:31,130 --> 01:00:33,900
>> 그리고 장담 기꺼이 당신들
모든 것을 알아 낸 것

1211
01:00:33,900 --> 01:00:37,940
너무 빨리, 당신은 넣어 필요가 있다고
마커의 일종 거기에 파악하기

1212
01:00:37,940 --> 01:00:39,190
당신이 어디에 있는지 알아.

1213
01:00:39,190 --> 01:00:41,540

1214
01:00:41,540 --> 01:00:44,550
즉, 다시 일의 힘
의사 코드를 미리.

1215
01:00:44,550 --> 01:00:47,310
그래서 우리는 먼저 논리를 수행 할 수 있습니다
우리는 구문이 있습니다.

1216
01:00:47,310 --> 01:00:51,470
>> 우리는 논리에 대해 혼란스러워했다
반면 C에서이 코드를 작성하려고,

1217
01:00:51,470 --> 01:00:53,110
우리는 모두 엉망받은 것입니다.

1218
01:00:53,110 --> 01:00:56,340
그리고 우리에 대한 질문을 할 것
논리와 구문 및 메쉬

1219
01:00:56,340 --> 01:00:57,320
함께 모두.

1220
01:00:57,320 --> 01:01:02,170
그리고 우리는 잃어버린받은 것
신속하게 될 수 있으므로,

1221
01:01:02,170 --> 01:01:04,000
매우 어려운 문제.

1222
01:01:04,000 --> 01:01:08,680
그래서 지금 이동하자
선택 정렬합니다.

1223
01:01:08,680 --> 01:01:10,760
>> 우리는 왼쪽으로 20 분 있습니다.

1224
01:01:10,760 --> 01:01:14,130
그래서 우리가 할 수 없습니다 느낌이
선택 정렬의 모든 통과

1225
01:01:14,130 --> 01:01:15,940
거품 정렬.

1226
01:01:15,940 --> 01:01:20,670
그러나 우리는 적어도 시도하자
선택 정렬을 완료합니다.

1227
01:01:20,670 --> 01:01:23,540
그래서 정렬하여 선택을 구현하는
함수 선언을 다음.

1228
01:01:23,540 --> 01:01:27,530
>> 다시 말하지만, 이것은에서 가져온 것입니다
문제는 사양을 설정합니다.

1229
01:01:27,530 --> 01:01:31,560
중간 값은 괄호입니다
정수의 배열.

1230
01:01:31,560 --> 01:01:33,490
그리고 int.n는 해당 배열의 크기입니다.

1231
01:01:33,490 --> 01:01:36,840
선택의 종류는 것입니다
이 배열을 정렬합니다.

1232
01:01:36,840 --> 01:01:43,580
>> 선택의 우리의 정신 모델 당 그래서
종류, 우리는 풀 -

1233
01:01:43,580 --> 01:01:47,720
첫째, 우리는리스트를 통해 제 갈
시간은 가장 작은 번호를 확인,

1234
01:01:47,720 --> 01:01:52,860
시작 부분에 넣어, 두 번째를 찾을 수
작은 숫자는에 넣어

1235
01:01:52,860 --> 01:01:56,380
우리가 원하는 경우 두 번째 위치
오름차순으로 정렬.

1236
01:01:56,380 --> 01:01:58,440
난 당신이 작성하는 강제 아니에요
의사 코드를 지금.

1237
01:01:58,440 --> 01:02:01,350
>> 그러나 우리의 클래스로 코드를하기 전에
5 분 우리는 쓸거야

1238
01:02:01,350 --> 01:02:03,550
의사 코드 그래서 우리는 어떤 의미를 가지고
의 위치를​​ 우리는 것입니다.

1239
01:02:03,550 --> 01:02:05,630
그래서 의사 코드를 작성하려고 시도
자신에.

1240
01:02:05,630 --> 01:02:08,610
그리고 그 다음을 설정하려고 시도
코드로 의사 코드.

1241
01:02:08,610 --> 01:02:10,740
우리는 그룹으로 그렇게 할 것이다
분 동안.

1242
01:02:10,740 --> 01:02:32,560

1243
01:02:32,560 --> 01:02:33,895
>> 그리고 물론, 알려 경우
당신은 질문이있는 경우에는.

1244
01:02:33,895 --> 01:03:56,738

1245
01:03:56,738 --> 01:03:58,230
>> 학생 : 그래?

1246
01:03:58,230 --> 01:04:00,280
>> 제이슨 허쉬 호른 : 얼마나 멀리보기
두 분 이상에서 얻을 수 있습니다.

1247
01:04:00,280 --> 01:04:01,790
당신이하지 않습니다 이해
완료 할 수 있습니다.

1248
01:04:01,790 --> 01:04:03,050
그러나 우리는 그룹으로이 이상 갈 것입니다.

1249
01:04:03,050 --> 01:04:57,830

1250
01:04:57,830 --> 01:05:00,630
>> 당신은 모든 들리지]를 코딩하고, 그래서 난
당신이 무슨 일을하는지 일시 정지 죄송합니다.

1251
01:05:00,630 --> 01:05:02,530
그러나의 그룹으로이 통.

1252
01:05:02,530 --> 01:05:07,590
그리고 또, 이진 검색, 당신 모두 제공
나 하나의 코드의 더 많은 라인이 아니라면.

1253
01:05:07,590 --> 01:05:08,530
이 주셔서 감사합니다.

1254
01:05:08,530 --> 01:05:11,730
우리는 같은 일을 할거야
여기에, 그룹으로 함께 코드입니다.

1255
01:05:11,730 --> 01:05:15,170
>> 그래서 선택의 종류 -의 작성하자
빠른 의사 코드.

1256
01:05:15,170 --> 01:05:20,380
정신 모델에 대해, 누군가가 나에게 줄 수있는
의사 코드의 첫 번째 줄, 제발?

1257
01:05:20,380 --> 01:05:23,000

1258
01:05:23,000 --> 01:05:24,270
나는 무엇을 하시겠습니까?

1259
01:05:24,270 --> 01:05:27,070
>> 학생 : 동안 목록
순서가 있습니다.

1260
01:05:27,070 --> 01:05:30,630
>> 제이슨 허쉬 호른 : OK, 동안
이 목록에는 순서가있다.

1261
01:05:30,630 --> 01:05:33,540
그리고 당신은 "순서가있다"는 게 무슨 뜻이야?

1262
01:05:33,540 --> 01:05:34,960
>> 학생 : 동안 [청취]

1263
01:05:34,960 --> 01:05:36,210
정렬되지 않았습니다.

1264
01:05:36,210 --> 01:05:38,460

1265
01:05:38,460 --> 01:05:40,290
>> 제이슨 허쉬 호른 : 동안 목록
순서가, 우리는 무엇을해야합니까?

1266
01:05:40,290 --> 01:05:44,200
나에게 두 번째 라인을 제공,
제발, 마커스.

1267
01:05:44,200 --> 01:05:47,186
>> 학생 : 그래서 다음 찾기
가장 작은 수입니다.

1268
01:05:47,186 --> 01:05:49,000
이 들여 쓰기됩니다.

1269
01:05:49,000 --> 01:05:55,140
>> 제이슨 허쉬 호른 : 그래서 찾아
다음으로 작은 수입니다.

1270
01:05:55,140 --> 01:05:56,460
그리고 다른 사람?

1271
01:05:56,460 --> 01:06:01,030
우리는 다음으로 작은를 찾으면
수, 우리는 무엇을해야합니까?

1272
01:06:01,030 --> 01:06:03,010
내가 찾을 말을거야
가장 작은 수입니다.

1273
01:06:03,010 --> 01:06:04,820
즉, 우리가하려는 것입니다.

1274
01:06:04,820 --> 01:06:06,210
>> 따라서 가장 작은 수를 찾을 수 있습니다.

1275
01:06:06,210 --> 01:06:08,061
그렇다면 우리는 무엇을해야합니까?

1276
01:06:08,061 --> 01:06:09,480
>> 학생 : [청취] 시작합니다.

1277
01:06:09,480 --> 01:06:10,680
>> 제이슨 허쉬 호른 : 죄송합니다?

1278
01:06:10,680 --> 01:06:12,700
>> 학생 :에 배치
목록의 시작.

1279
01:06:12,700 --> 01:06:18,540
>> 제이슨 허쉬 호른 : 그래서에 배치
목록의 시작 부분.

1280
01:06:18,540 --> 01:06:20,140
그리고 우리는 일에 무엇을해야합니까
그 시작이었다

1281
01:06:20,140 --> 01:06:20,830
목록, 오른쪽?

1282
01:06:20,830 --> 01:06:21,910
우리는 뭔가를 덮어입니다.

1283
01:06:21,910 --> 01:06:23,130
어디 우리가 넣을까요?

1284
01:06:23,130 --> 01:06:24,120
네, 안나?

1285
01:06:24,120 --> 01:06:25,520
>> 학생 : 어디 작은
수 있었다?

1286
01:06:25,520 --> 01:06:32,530
>> 제이슨 허 시혼 : 그래서 시작을 넣어
목록의 위치를

1287
01:06:32,530 --> 01:06:35,180
작은 숫자였다.

1288
01:06:35,180 --> 01:06:38,510
목록 순서가 그래서있는 동안, 발견
작은 숫자에 배치

1289
01:06:38,510 --> 01:06:40,630
목록의 시작 부분은 넣어
목록의 시작 위치

1290
01:06:40,630 --> 01:06:42,900
작은 숫자였다.

1291
01:06:42,900 --> 01:06:45,780
마커스,이 라인을 바꿔 수 있습니다
리스트는 순서가있는 동안?

1292
01:06:45,780 --> 01:06:51,160

1293
01:06:51,160 --> 01:06:53,900
>> 학생 : 동안 번호
분류되지 않은?

1294
01:06:53,900 --> 01:06:55,920
>> 제이슨 허 시혼 : OK, 그래서 순서에
숫자가되지 않았 음을 알

1295
01:06:55,920 --> 01:06:58,670
분류, 우리는 무엇을해야합니까?

1296
01:06:58,670 --> 01:07:00,640
우리는에 얼마나 필요합니까
이 목록을 통해 이동?

1297
01:07:00,640 --> 01:07:09,650
>> 학생 : 그래서 루프를 추측, 또는
반면, 숫자를 체크하면서 작

1298
01:07:09,650 --> 01:07:11,900
목록의 길이보다?

1299
01:07:11,900 --> 01:07:13,160
>> 제이슨 허 시혼 : 좋아, 좋다.

1300
01:07:13,160 --> 01:07:15,000
나는 misphrased 생각
내 질문에 제대로.

1301
01:07:15,000 --> 01:07:15,990
난 그냥 얻을 것을 시도하고 있었다
우리가 가야 할거야

1302
01:07:15,990 --> 01:07:17,580
전체 목록을.

1303
01:07:17,580 --> 01:07:20,490
목록 순서가 그래서있는 동안,
저를 위해,에지도하기 어렵다.

1304
01:07:20,490 --> 01:07:24,940
그러나 기본적으로, 그건 방법
나는 이것에 대해 생각합니다.

1305
01:07:24,940 --> 01:07:28,880
찾기, 전체 목록을 이동
최소 개수에 게재

1306
01:07:28,880 --> 01:07:30,130
시작 - 실제로, 당신 말이 맞아.

1307
01:07:30,130 --> 01:07:31,380
의는 둘 다 넣어 보자.

1308
01:07:31,380 --> 01:07:33,470

1309
01:07:33,470 --> 01:07:39,050
>> 리스트는 순서가 그래서있는 동안, 우리
전체 목록을 이동해야

1310
01:07:39,050 --> 01:07:42,250
한 번, 작은 숫자, 장소를 찾아
그 목록의 시작 부분에 넣어

1311
01:07:42,250 --> 01:07:45,430
리스트의 처음 어디에
작은 수이고, 그 다음 단계

1312
01:07:45,430 --> 01:07:47,460
목록은 우리가했습니다, 순서가 여전히
이를 통해 가야

1313
01:07:47,460 --> 01:07:48,620
프로세스를 다시, 오른쪽?

1314
01:07:48,620 --> 01:07:51,610
그 이유는 선택 정렬, 빅-O 런타임에게의
선택 종류의, 누구?

1315
01:07:51,610 --> 01:07:52,830
>> 학생 : N 제곱.

1316
01:07:52,830 --> 01:07:53,590
>> 제이슨 허 시혼 : N 제곱.

1317
01:07:53,590 --> 01:07:57,040
마커스 난 그냥 실현 좋아하기 때문에
여기에, 우리는해야 할 것입니다

1318
01:07:57,040 --> 01:08:00,310
리스트 목록을 통해 이동
횟수.

1319
01:08:00,310 --> 01:08:03,420
그래서 뭔가를 거치지
길이 N N 횟수

1320
01:08:03,420 --> 01:08:04,990
실제로 N 제곱.

1321
01:08:04,990 --> 01:08:08,100
>> 그래서 이것은 우리의 의사입니다.

1322
01:08:08,100 --> 01:08:09,360
이것은 매우 좋은 것 같습니다.

1323
01:08:09,360 --> 01:08:11,870
아무도 질문이 있습니까
의사에 대한?

1324
01:08:11,870 --> 01:08:14,440
실제로 선택의 종류가해야하기 때문에
아마에서 하나의 코드를 올

1325
01:08:14,440 --> 01:08:14,980
의사.

1326
01:08:14,980 --> 01:08:17,569
에 대한 그래서 질문
의사의 논리?

1327
01:08:17,569 --> 01:08:18,819
지금 문의하십시오.

1328
01:08:18,819 --> 01:08:22,609

1329
01:08:22,609 --> 01:08:25,379
>> 선택 정렬 - 목록이 밖으로있는 동안
위해, 우리는 그것을 통해 갈거야

1330
01:08:25,379 --> 01:08:27,529
가장 작은마다 찾아
전면에 넣어.

1331
01:08:27,529 --> 01:08:33,470
목록 수, 순서가 그래서있는 동안
누군가가 나에게 코드 줄을주는 사람

1332
01:08:33,470 --> 01:08:39,689
나에게 라인을 작성하지 않았습니다
는 아직 코드?

1333
01:08:39,689 --> 01:08:40,939
그것은 무엇을 같은 소리?

1334
01:08:40,939 --> 01:08:43,669

1335
01:08:43,669 --> 01:08:44,649
>> 학생 : 그 루프입니다.

1336
01:08:44,649 --> 01:08:45,830
>> 제이슨 허 시혼 : 소리가 난다
루프를 좋아한다.

1337
01:08:45,830 --> 01:08:47,653
OK, 당신은 저에게 루프를 줄 수 있습니까?

1338
01:08:47,653 --> 01:08:48,925
용 -

1339
01:08:48,925 --> 01:08:50,219
>> 학생 : 0 같음.

1340
01:08:50,219 --> 01:08:52,705
>> 제이슨 허 시혼 : i 또는 -

1341
01:08:52,705 --> 01:08:55,111
우리는 무엇을 누락?

1342
01:08:55,111 --> 01:08:56,819
어떻게 여기 간다?

1343
01:08:56,819 --> 01:08:57,550
>> 학생 :이자.

1344
01:08:57,550 --> 01:08:59,270
>> 제이슨 허 시혼 : 그렇지.

1345
01:08:59,270 --> 01:09:02,590
-;은 (i = 0 int로

1346
01:09:02,590 --> 01:09:07,843
>> 학생 : 나는 N <나는 + +).

1347
01:09:07,843 --> 01:09:09,319
>> 제이슨 허 시혼 : 제프를 맞았다.

1348
01:09:09,319 --> 01:09:10,660
우리는 오른쪽 목록을 거 야?

1349
01:09:10,660 --> 01:09:11,880
우리는 그 전에 코드를 본 적이있다.

1350
01:09:11,880 --> 01:09:12,850
완벽한.

1351
01:09:12,850 --> 01:09:14,790
그래서 여기에 우리의 중괄호를 만들어 보자.

1352
01:09:14,790 --> 01:09:17,859
나는 약간을 넣어 갈거야
여기에 중괄호.

1353
01:09:17,859 --> 01:09:21,660
>> 그것은 0의 동안 그래서, 우리는 갈 필요가
전체 목록을.

1354
01:09:21,660 --> 01:09:26,612
그래서 때마다 우리는 목록을 통해 이동
우리는 무엇을 추적 할 수 있습니까?

1355
01:09:26,612 --> 01:09:28,260
>> 학생 : 어떤 스왑이 이루어질 경우.

1356
01:09:28,260 --> 01:09:29,069
>> 제이슨 허 시혼 : 찾기
가장 작은 수입니다.

1357
01:09:29,069 --> 01:09:31,479
그래서 우리는 아마 트랙을 유지해야
작은 숫자마다.

1358
01:09:31,479 --> 01:09:34,590
그래서 라인 전을 추적 할 수있는
가장 적은 수의?

1359
01:09:34,590 --> 01:09:37,720
Aleha, 어떻게 유지할 수 있습니다
뭔가를 추적?

1360
01:09:37,720 --> 01:09:38,460
>> 학생 : 새 변수를 시작합니다.

1361
01:09:38,460 --> 01:09:39,390
>> 제이슨 허 시혼 : 새 변수를 시작합니다.

1362
01:09:39,390 --> 01:09:40,069
그래서 변수를 만들 수 있습니다.

1363
01:09:40,069 --> 01:09:41,830
어떤 종류의?

1364
01:09:41,830 --> 01:09:42,930
>> 학생 :이자.

1365
01:09:42,930 --> 01:09:43,710
>> 제이슨 허 시혼 :이자.

1366
01:09:43,710 --> 01:09:44,939
의 가장 작은 호출 할 수 있습니다.

1367
01:09:44,939 --> 01:09:47,600
그리고 어떻게이 같은 경우 수행
우리는 그냥 시작거야?

1368
01:09:47,600 --> 01:09:48,910
우리는 아직리스트를 통과하지 않았습니다.

1369
01:09:48,910 --> 01:09:50,540
우리의 첫번째 부분에있어
을 통해 우리의 첫 시간을 보여줍니다.

1370
01:09:50,540 --> 01:09:51,930
이 같은 무엇,
작은 수?

1371
01:09:51,930 --> 01:09:54,140
>> 학생 : 값 나.

1372
01:09:54,140 --> 01:09:54,900
>> 제이슨 허 시혼 : 값 나.

1373
01:09:54,900 --> 01:09:56,980
그건 바로, 정확히 바로 소리?

1374
01:09:56,980 --> 01:09:59,590
처음에 작은 수
우리가있는 곳입니다.

1375
01:09:59,590 --> 01:10:01,960
그래서 지금 우리는 우리의 작은이, 우리는 필요
전체 목록을 통해 이동합니다

1376
01:10:01,960 --> 01:10:05,080
작은이를 비교
다른 모든 것들에.

1377
01:10:05,080 --> 01:10:08,150
그래서 우리는 다시 목록을 가야합니까?

1378
01:10:08,150 --> 01:10:08,630
마이클?

1379
01:10:08,630 --> 01:10:10,000
>> 학생 : 당신은해야
루프의 또 다른.

1380
01:10:10,000 --> 01:10:10,383
>> 제이슨 허 시혼 : 루프의 또 다른.

1381
01:10:10,383 --> 01:10:11,276
그것을 해 보자.

1382
01:10:11,276 --> 01:10:12,540
나에게 몇 가지 코드를 제공합니다.

1383
01:10:12,540 --> 01:10:13,790
>> 학생 : 루프 -

1384
01:10:13,790 --> 01:10:16,750

1385
01:10:16,750 --> 01:10:19,470
작은 용 -

1386
01:10:19,470 --> 01:10:23,040

1387
01:10:23,040 --> 01:10:25,770
다만 J를 중간, 당신은 말할 수 있는가?

1388
01:10:25,770 --> 01:10:31,150
= 0;되도록 -

1389
01:10:31,150 --> 01:10:34,014

1390
01:10:34,014 --> 01:10:35,710
>> 제이슨 허 시혼 : 글쎄, 우리가 원하는 경우
전체 목록을 이동합니다 -

1391
01:10:35,710 --> 01:10:37,847
>> 학생 : J <N, J + +).

1392
01:10:37,847 --> 01:10:42,140

1393
01:10:42,140 --> 01:10:42,405
>> 제이슨 허 시혼 : 환상적인.

1394
01:10:42,405 --> 01:10:46,100
우리는 통과거야
루프를 다시 한 번.

1395
01:10:46,100 --> 01:10:51,380
그리고 우리는 어떻게 찾을 수 있습니까
작은 수?

1396
01:10:51,380 --> 01:10:52,630
톰?

1397
01:10:52,630 --> 01:10:54,570

1398
01:10:54,570 --> 01:11:00,520
우리는 현재의 작은 숫자를 가지고,
그래서 우리는 어떻게 새로운 최소를 찾을 수 있습니까?

1399
01:11:00,520 --> 01:11:07,200
>> 학생 : 우리는 확인할 수 있습니다 경우 최소
우리가 가지고있는 수보다 큰 경우

1400
01:11:07,200 --> 01:11:09,040
브래킷 J 값.

1401
01:11:09,040 --> 01:11:14,740
>> 제이슨 허 시혼 : 그래서 작은 경우
값 브래킷 J보다 큰.

1402
01:11:14,740 --> 01:11:19,350
그렇다면 현재의 작은
보다 큰 -

1403
01:11:19,350 --> 01:11:21,770
이 두 줄을 이동하는거야
초 밖에 코드.

1404
01:11:21,770 --> 01:11:26,010
때문에 우리는 스와핑을하기 전에, 우리
전체 목록을 이동해야합니다.

1405
01:11:26,010 --> 01:11:28,880
그래서이 의사가 실제로해야
루프에 대한 내면의 외부에있을 수.

1406
01:11:28,880 --> 01:11:30,390
따라서 전체 목록을 이동합니다.

1407
01:11:30,390 --> 01:11:34,520
최소는보다 크면
값 J 다음 무엇?

1408
01:11:34,520 --> 01:11:37,830
>> 학생 : 그런 작은
값 J 같습니다.

1409
01:11:37,830 --> 01:11:41,190

1410
01:11:41,190 --> 01:11:42,600
>> 제이슨 허 시혼 : 환상적인.

1411
01:11:42,600 --> 01:11:44,580
한 빠른 질문 -

1412
01:11:44,580 --> 01:11:47,236
우리는이 루프를 통해 이동 처음으로,
난 0과 동일 것, j는거야

1413
01:11:47,236 --> 01:11:50,710
우리가 여기에 도착하면 0과 동일합니다.

1414
01:11:50,710 --> 01:11:52,410
그래서 우리는 비교 될 것입니다
자체에 대한 수.

1415
01:11:52,410 --> 01:11:53,660
즉, 효율적인가요?

1416
01:11:53,660 --> 01:11:57,260

1417
01:11:57,260 --> 01:11:58,390
아니, 정말 효율적으로하지 않습니다.

1418
01:11:58,390 --> 01:12:02,915
그래서 우리의 j는 갈 필요가 없습니다
0에서 각 시간을 n으로?

1419
01:12:02,915 --> 01:12:06,310
우리는 항상 체크해야
전체 목록을?

1420
01:12:06,310 --> 01:12:06,520
[들리지?

1421
01:12:06,520 --> 01:12:07,564
>> 학생 : 대신 내가 함께 시작합니다.

1422
01:12:07,564 --> 01:12:09,405
>> 제이슨 허 시혼 : J 캔
어떻게 시작?

1423
01:12:09,405 --> 01:12:09,990
>> 학생 :.

1424
01:12:09,990 --> 01:12:13,040
>> 제이슨 허 시혼 : j는 내가 함께 시작할 수 있습니다.

1425
01:12:13,040 --> 01:12:18,840
그래서 지금 우리가 시작 비교할
우리가에있어 하나.

1426
01:12:18,840 --> 01:12:21,020
하지만 그렇다하더라도, 그 같다
가능한 한 효율적인가요?

1427
01:12:21,020 --> 01:12:22,320
>> 학생 : 1 +.

1428
01:12:22,320 --> 01:12:25,420
>> 제이슨 허 시혼 : 나는 + 1이 될 것으로 보인다
가장 효율적인 때문에 우리

1429
01:12:25,420 --> 01:12:26,120
이미 난이 있습니다.

1430
01:12:26,120 --> 01:12:28,100
우리는 그 진술하고있는
15 행에서 가장 작은.

1431
01:12:28,100 --> 01:12:29,350
우리는 시작하는거야
다음 중 하나를 자동.

1432
01:12:29,350 --> 01:12:34,470

1433
01:12:34,470 --> 01:12:38,540
그래서 우리는 루프를 통해 이동합니다.

1434
01:12:38,540 --> 01:12:39,620
우리는 각각의 시간을 통해 이동합니다.

1435
01:12:39,620 --> 01:12:40,860
우리는 시간의 숫자를 통해 갈 수 있습니다.

1436
01:12:40,860 --> 01:12:42,860
이제 우리는을 통해 들어 왔
루프이 내부.

1437
01:12:42,860 --> 01:12:44,350
우리는 가장 작은 값을 절약 할 수있다.

1438
01:12:44,350 --> 01:12:46,045
우리는에 배치해야
목록의 시작.

1439
01:12:46,045 --> 01:12:48,390
그래서 어떻게에 배치 않습니다
목록의 시작?

1440
01:12:48,390 --> 01:12:51,290

1441
01:12:51,290 --> 01:12:55,926
참조하는 변수는 무엇입니까
목록의 시작 부분에?

1442
01:12:55,926 --> 01:13:00,500
우리는 루프이 외부에있어
그래서 무엇을 의미

1443
01:13:00,500 --> 01:13:01,280
목록의 시작?

1444
01:13:01,280 --> 01:13:02,880
>> 학생 : 값 나.

1445
01:13:02,880 --> 01:13:03,510
>> 제이슨 허 시혼 : 맞아 맞아.

1446
01:13:03,510 --> 01:13:04,650
값 난의 시작입니다 -

1447
01:13:04,650 --> 01:13:06,320
또는 죄송합니다, 시작하지.

1448
01:13:06,320 --> 01:13:07,090
즉, 혼란이었다.

1449
01:13:07,090 --> 01:13:11,620
우리의 시작 부분에있는 곳이에요
목록의 정렬되지 않은 부분입니다.

1450
01:13:11,620 --> 01:13:12,800
그래서 내가 값.

1451
01:13:12,800 --> 01:13:14,050
그리고 무슨 일이 동일한 것이 무엇입니까?

1452
01:13:14,050 --> 01:13:15,925

1453
01:13:15,925 --> 01:13:17,326
>> 학생 : 작은.

1454
01:13:17,326 --> 01:13:18,862
>> 제이슨 허 시혼 : 값이 어떻게 동일?

1455
01:13:18,862 --> 01:13:19,310
>> 학생 : 작은.

1456
01:13:19,310 --> 01:13:20,030
>> 제이슨 허 시혼 : 작은.

1457
01:13:20,030 --> 01:13:20,980
정확히 맞아.

1458
01:13:20,980 --> 01:13:23,510
그래서 우리는 처음에 배치하고
목록으로, 그리고 지금 우리 둘 필요가

1459
01:13:23,510 --> 01:13:25,710
목록의 시작 위치
가장 적은 수였다.

1460
01:13:25,710 --> 01:13:29,700
그래서 내가 어떻게 작성하는 곳
작은 숫자였다?

1461
01:13:29,700 --> 01:13:31,670
어떤 값?

1462
01:13:31,670 --> 01:13:33,170
>> 학생 : 0.

1463
01:13:33,170 --> 01:13:34,090
>> 제이슨 허 시혼 : 작은
번호는 0에서입니까?

1464
01:13:34,090 --> 01:13:35,340
>> 학생 : 네.

1465
01:13:35,340 --> 01:13:38,680

1466
01:13:38,680 --> 01:13:39,910
>> 제이슨 허 시혼 : 어떤 경우 최소
번호의 끝에 있었다

1467
01:13:39,910 --> 01:13:40,860
이 정렬되지 않은 목록?

1468
01:13:40,860 --> 01:13:42,460
>> 학생 : 죄송합니다, 문제는 무엇 이었습니까?

1469
01:13:42,460 --> 01:13:44,020
>> 제이슨 허 시혼 : 어디
가장 적은 수의?

1470
01:13:44,020 --> 01:13:46,940
우리는 작은를 가져다가에 넣어
여기이 선으로 시작.

1471
01:13:46,940 --> 01:13:48,987
>> 학생 : 그것은해야
일부에 저장된 -

1472
01:13:48,987 --> 01:13:50,510
>> 학생 : 값 J.

1473
01:13:50,510 --> 01:13:51,520
>> 제이슨 허 시혼 : 글쎄, 그건
반드시 j는 값.

1474
01:13:51,520 --> 01:13:54,100
심지어이 시점에서 존재하지 않습니다.

1475
01:13:54,100 --> 01:13:55,960
>> 학생 : 당신은 선언해야한다
변수 이전 및

1476
01:13:55,960 --> 01:13:58,230
다음에 할당 -

1477
01:13:58,230 --> 01:14:01,150
당신은 가장 작은 번호를 찾을 때,
해당 번호의 인덱스를 할당

1478
01:14:01,150 --> 01:14:02,480
약간의 변수 또는 그런 일.

1479
01:14:02,480 --> 01:14:04,790
>> 제이슨 허 시혼 : 그래서 할 수
다시 그런 말을?

1480
01:14:04,790 --> 01:14:08,390
>> 학생 : 그래서 당신은 INT를 선언 곳
작은, 당신은 또한 INT를 선언해야

1481
01:14:08,390 --> 01:14:10,750
작은 인덱스 = I, 또는
그런 식으로.

1482
01:14:10,750 --> 01:14:13,280
>> 제이슨 허 시혼 : 그래서 int로하는 곳
작은, 내가 트랙을 유지해야합니다뿐만 아니라,

1483
01:14:13,280 --> 01:14:16,150
값하지만 위치.

1484
01:14:16,150 --> 01:14:20,850
INT smallest_location =이있는
경우, 우리는 단지 내가 할 수 있습니다.

1485
01:14:20,850 --> 01:14:22,390
우리는 그것이 어디에 있는지 알고 있어야합니다.

1486
01:14:22,390 --> 01:14:26,820
우리는 코드의 단부에있어, 우리
우리는 그것을했다 몰랐다 깨달았다.

1487
01:14:26,820 --> 01:14:29,810
그리고 다시, 우리는 매핑합니다
이것과 하나.

1488
01:14:29,810 --> 01:14:32,890
자신의 의지에이 코딩 너희들
아마 같은 문제에 도착.

1489
01:14:32,890 --> 01:14:34,130
나는 어떻게 도대체 그것을 찾을 수 있습니까?

1490
01:14:34,130 --> 01:14:36,720
그리고 당신은 내가 기다린 실현
그 추적 할 필요가있다.

1491
01:14:36,720 --> 01:14:38,500
>> 그래서 최소가 크면
값 J보다.

1492
01:14:38,500 --> 01:14:39,740
우리는 작은 값의 J로 동일 설정합니다.

1493
01:14:39,740 --> 01:14:42,090
우리가 변경 다른 무엇이 필요합니까?

1494
01:14:42,090 --> 01:14:43,710
콘스탄틴, 다른 무엇을 할
우리는 변경해야합니까?

1495
01:14:43,710 --> 01:14:44,560
>> 학생 : 위치입니다.

1496
01:14:44,560 --> 01:14:45,270
>> 제이슨 허 시혼 : 그렇지.

1497
01:14:45,270 --> 01:14:46,925
그래서 나에게 코드에서 해당 라인을 제공합니다.

1498
01:14:46,925 --> 01:14:53,310
>> 학생 : smallest_location = J.

1499
01:14:53,310 --> 01:14:54,790
>> 제이슨 허 시혼 : 그렇지.

1500
01:14:54,790 --> 01:14:58,210
그리고 말에서 내려, 우리는 원하는 경우
목록의 시작을 어디다

1501
01:14:58,210 --> 01:15:00,790
작은 숫자는 얼마나
우리는 어디를 참조 않는다

1502
01:15:00,790 --> 01:15:02,200
작은 숫자였다?

1503
01:15:02,200 --> 01:15:03,580
마커스?

1504
01:15:03,580 --> 01:15:08,530
>> 학생 : 작은 숫자였다
작은 위치에 있습니다.

1505
01:15:08,530 --> 01:15:12,230
>> 제이슨 허 시혼 : 그래서 값에
smallest_location.

1506
01:15:12,230 --> 01:15:14,700
그리고 우리가 무엇을 입력해야합니까?

1507
01:15:14,700 --> 01:15:17,600
의 시작
목록, 그게 뭔데?

1508
01:15:17,600 --> 01:15:19,710
>> 학생 : 음, 우리가 정말 모르겠어요
우리는 더 이상 덮어 쓰기 때문입니다.

1509
01:15:19,710 --> 01:15:23,250
그래서 교환 위치의
두 라인의?

1510
01:15:23,250 --> 01:15:26,110
당신은 주변 사람들 두 줄을 전환하는 경우.

1511
01:15:26,110 --> 01:15:30,740
>> 제이슨 허 시혼 : OK, 그래서 우리는하지 않습니다
더 이상, 때문에 우리는 라인을 다시 한

1512
01:15:30,740 --> 01:15:31,960
값 난 작은에 이전.

1513
01:15:31,960 --> 01:15:33,810
그래서 우리는 그 초기 값을 잃었다.

1514
01:15:33,810 --> 01:15:37,350
그래서 당신은 스왑이 두 줄 말했다.

1515
01:15:37,350 --> 01:15:41,780
이제 목록의 시작 부분을 넣어
여기서 가장 적은 수였다.

1516
01:15:41,780 --> 01:15:47,060
그래서 smallest_location 내가 값을 동일합니다.

1517
01:15:47,060 --> 01:15:51,310
즉,이의 시작을 움직이고
에있는 목록의 정렬되지 않은 부분

1518
01:15:51,310 --> 01:15:52,090
작은 위치.

1519
01:15:52,090 --> 01:15:54,860
그리고 그 값으로 우리는 이동한다
그 작은 숫자.

1520
01:15:54,860 --> 01:15:57,450
>> 않는다는 말이 왜
그 스왑을했다?

1521
01:15:57,450 --> 01:15:59,650
우리는 그 값을 덮어 쓸 것이다 -
당신은 아마있을 것 다른 것

1522
01:15:59,650 --> 01:16:02,740
파악 및 GDP에서 발견.

1523
01:16:02,740 --> 01:16:05,310
그래서 우리는 신세를했습니다
모든 의사.

1524
01:16:05,310 --> 01:16:10,935
다른 사람 있나요 우리
여기에 작성해야?

1525
01:16:10,935 --> 01:16:14,911
사람은 아무것도 생각할 수 있습니까?

1526
01:16:14,911 --> 01:16:16,180
>> 학생 : 어떻게 알 수 있습니까
당신이 완료되면?에게

1527
01:16:16,180 --> 01:16:17,680
>> 제이슨 허 시혼 : 우리는 어떻게 할
우리가 완료되면 알아?

1528
01:16:17,680 --> 01:16:18,890
좋은 질문.

1529
01:16:18,890 --> 01:16:21,684
그렇다면 우리는 우리가 완료되면 알고있다.

1530
01:16:21,684 --> 01:16:24,720
>> 학생 : 수를 유지하는 변수를 만듭니다
이없는 한 스왑의 또는의 경우

1531
01:16:24,720 --> 01:16:27,810
과 패스를 통해 이동합니다.

1532
01:16:27,810 --> 01:16:30,180
>> 제이슨 허 시혼 : OK.

1533
01:16:30,180 --> 01:16:31,800
즉, 버블 정렬에서 작동합니다.

1534
01:16:31,800 --> 01:16:35,210
그러나 선택의 종류에 대한, 우리가하지 않으면
스왑을, 그것은 단지 수 있습니다

1535
01:16:35,210 --> 01:16:38,670
작은 값이기 때문
거기에 오른쪽 위치.

1536
01:16:38,670 --> 01:16:41,240
우리는 목록 1, 2, 4, 3이있을 수 있습니다.

1537
01:16:41,240 --> 01:16:42,830
우리를 통해 두 번째
모든 스왑을하지 않습니다.

1538
01:16:42,830 --> 01:16:47,260
우리는 숫자 2에있을거야,하지만 우리는거야
아직도 계속해야합니다.

1539
01:16:47,260 --> 01:16:49,390
그래서 우리가 추적 할 필요가
우리는 완료, 우리는 그냥 가고 싶어

1540
01:16:49,390 --> 01:16:50,640
이 작업은 완료 될 때까지?

1541
01:16:50,640 --> 01:16:54,098

1542
01:16:54,098 --> 01:16:56,740
>> 학생 : 우리는 그냥 갈 수 있습니다
그것이 완료 될 때까지.

1543
01:16:56,740 --> 01:16:58,090
>> 제이슨 허 시혼 : 우리는 할 수 단지
이 완료 될 때까지 이동합니다.

1544
01:16:58,090 --> 01:17:01,720
버블 정렬, 당신은 정확히 맞아
솔루션과 제프와 Aleha -

1545
01:17:01,720 --> 01:17:04,990
그것은 추적하는 좋은 방법 많은
스왑 당신이 만든 때문에 거품

1546
01:17:04,990 --> 01:17:07,920
당신이 실제로 할 경우, 정렬, 아니 스왑을하지 않습니다
당신이 완료 당신은 어쩌면 당신의 절단 할 수

1547
01:17:07,920 --> 01:17:09,000
문제가 아래로 약간.

1548
01:17:09,000 --> 01:17:11,440
그러나 선택의 종류에 대해, 당신은 정말했습니다
의 끝까지 가야

1549
01:17:11,440 --> 01:17:14,940
주위에 각각의 시간을 보여줍니다.

1550
01:17:14,940 --> 01:17:16,200
>> 그래서이 있다는 것입니다.

1551
01:17:16,200 --> 01:17:18,530
우리는 왼쪽으로 2 분있다.

1552
01:17:18,530 --> 01:17:21,560
의 모두를 만들어 보자.

1553
01:17:21,560 --> 01:17:24,340
내가 그냥 개방 여기 찾아 만들자
확실히 나는 사실에 전화 했어요 -

1554
01:17:24,340 --> 01:17:25,610
나는 버블 정렬을 호출 아니에요.

1555
01:17:25,610 --> 01:17:29,230
이제 선택 정렬로 변경하자.

1556
01:17:29,230 --> 01:17:31,060
모두 확인합니다. / 찾을 수 있습니다.

1557
01:17:31,060 --> 01:17:32,360
의 (42)을 찾아 보자.

1558
01:17:32,360 --> 01:17:38,110
우리가 전달하는거야이 시간
정렬되지 않은 목록이 정렬해야하기 때문에

1559
01:17:38,110 --> 01:17:43,790
먼저 찾기 코드 당 - 정렬한다
먼저 우리의 정렬 기능을 사용하여

1560
01:17:43,790 --> 01:17:44,995
무언가를 찾습니다.

1561
01:17:44,995 --> 01:17:46,245
손가락 모두를 건넜다.

1562
01:17:46,245 --> 01:17:48,530

1563
01:17:48,530 --> 01:17:49,370
>> 맙소사.

1564
01:17:49,370 --> 01:17:50,800
우와, 내 심장이 두근 거리고 있었다.

1565
01:17:50,800 --> 01:17:52,320
그래서 정확합니다.

1566
01:17:52,320 --> 01:17:57,270
사실, 우리는이 더 실행 한 경우
지금까지 내가 할 수있는 광범위하게, 코드,

1567
01:17:57,270 --> 01:17:59,280
말해, 완벽하게 정확합니다.

1568
01:17:59,280 --> 01:18:02,150
몇 가지 제안이 있습니다
내가 당신을 위해 할 것입니다.

1569
01:18:02,150 --> 01:18:06,215
예를 들어, (15, 16)는 보이지
약간의 중복.

1570
01:18:06,215 --> 01:18:09,450
당신이 필요하지 않는 것 같다
두 사람을 저장해야합니다.

1571
01:18:09,450 --> 01:18:12,790
당신이 가장 작은 위치에, 당신이있는 경우
쉽게하여 작은 값을 찾을 수 있습니다

1572
01:18:12,790 --> 01:18:14,750
그냥 값을 입력.

1573
01:18:14,750 --> 01:18:18,100
>> 내가 코드를 채점하는 것처럼 그렇게
나는 사실, 내가하고자 할 것이다

1574
01:18:18,100 --> 01:18:21,160
당신이 경우 아마 점을 제외
,이 두 가지를 포함 당신 때문에

1575
01:18:21,160 --> 01:18:22,670
이 두 가지가 필요하지 않습니다.

1576
01:18:22,670 --> 01:18:25,400
당신은 위치가있는 경우에, 당신은 할 수 있습니다
아주 쉽게 값을 얻을.

1577
01:18:25,400 --> 01:18:27,520
그리고 그것은 조금 이상한 것 같다
이들 모두를 저장한다.

1578
01:18:27,520 --> 01:18:31,070
어쩌면 점을 가지고 있지만
확실히 그것은 어쩌면이라고 코멘트

1579
01:18:31,070 --> 01:18:32,670
하지 문체 선택
당신은 확인해야합니다.

1580
01:18:32,670 --> 01:18:35,290
물론, 코드 정지
완벽하게 실행됩니다.

1581
01:18:35,290 --> 01:18:36,860
>> 그래서 불행히도 우리는하지 않았다
버블 정렬에 도착.

1582
01:18:36,860 --> 01:18:37,940
미안하게 생각합니다.

1583
01:18:37,940 --> 01:18:39,135
우리는 마무리 선택 정렬을했다.

1584
01:18:39,135 --> 01:18:41,450
사람은 마지막 질문이 있습니까
선택의 종류는?

1585
01:18:41,450 --> 01:18:44,320

1586
01:18:44,320 --> 01:18:47,690
>> 우리는 밖으로 머리를하기 전에 확인, 내가 당신에게 원하는
크롬 브라우저를 엽니 다.

1587
01:18:47,690 --> 01:18:54,340
죄송합니다, 그건 그냥 뻔뻔스러운 플러그했다
인터넷 브라우저의 하나의 유형에 대한.

1588
01:18:54,340 --> 01:18:57,770
당신은 모든 종류의 브라우저를 열 수있다,
그러나 그것은 아마 크롬있을 것이다.

1589
01:18:57,770 --> 01:19:01,250
그리고이 다음 웹 사이트로 이동합니다 -

1590
01:19:01,250 --> 01:19:06,410
sayat.me/cs50.

1591
01:19:06,410 --> 01:19:07,685
당신은 당신의 컴퓨터에 입력하지 않는 경우
지금, 당신은 분명히있어

1592
01:19:07,685 --> 01:19:10,210
, 톰 그 일을하지.

1593
01:19:10,210 --> 01:19:12,870
>> 오른쪽 어느 해주세요
현재 또는 다음 시간에 -

1594
01:19:12,870 --> 01:19:14,260
나에게 몇 가지 조언을 준다.

1595
01:19:14,260 --> 01:19:15,660
이 섹션은 두 가지입니다.

1596
01:19:15,660 --> 01:19:18,060
우리는 함께 더 많은, 그래서 I
개선하기 위해 방을 많이 가지고 있어요.

1597
01:19:18,060 --> 01:19:19,620
나는 희망도 잘 몇 가지를했다.

1598
01:19:19,620 --> 01:19:22,160
그래서 당신은 내가 나쁜 느낌을 할 수 있지만, 경우
당신은 또한 저에게 웃는주고 싶어

1599
01:19:22,160 --> 01:19:24,250
얼굴, 나는 그뿐만 아니라 감사하겠습니다.

1600
01:19:24,250 --> 01:19:25,330
이 양식에 작성

1601
01:19:25,330 --> 01:19:28,210
>> 그리고 1 분 남았와,
그 주일이었다.

1602
01:19:28,210 --> 01:19:30,750
나는 조금 밖에 서 있습니다
당신은 질문이있는 경우.

1603
01:19:30,750 --> 01:19:32,220
나는 당신 사람을 볼 수 있습니다
내일 강의.

1604
01:19:32,220 --> 01:19:34,742