1
00:00:00,000 --> 00:00:03,332
>> [השמעת מוסיקה]

2
00:00:03,332 --> 00:00:06,490
>> ANDI פנג: ברוכים הבאים לשבוע של סעיף 3.

3
00:00:06,490 --> 00:00:09,550
תודה, אתם, לכל באים
לזמן התחלה מוקדם יותר היום.

4
00:00:09,550 --> 00:00:11,466
יש לנו נחמד, קטן
קבוצה אינטימית היום.

5
00:00:11,466 --> 00:00:14,570
אז אני מקווה שנגיע ל
גימור, אולי, מוקדם,

6
00:00:14,570 --> 00:00:15,780
קצת מוקדם היום.

7
00:00:15,780 --> 00:00:22,057
כל כך מהר, רק חלק
הודעות לסדר היום.

8
00:00:22,057 --> 00:00:23,890
לפני שנתחיל, אנחנו
הולך רק כדי לעבור על

9
00:00:23,890 --> 00:00:28,910
כמה בעיות לוגיסטיות קצרות, pset
שאלות, לתחקר, דברים כאלה.

10
00:00:28,910 --> 00:00:30,250
ואז לצלול ממש.

11
00:00:30,250 --> 00:00:34,710
אנו נשתמש הבאגים נקראים GDB ל
להתחיל מזלזל בקוד שלנו, שדוד

12
00:00:34,710 --> 00:00:36,550
הסביר בהרצאה ביום האחר.

13
00:00:36,550 --> 00:00:39,420
אנחנו נלך על ארבעה הסוגים של מיני.

14
00:00:39,420 --> 00:00:42,310
אנחנו נלך עליהם די מהר
מאז שהם די אינטנסיביים.

15
00:00:42,310 --> 00:00:45,710
אבל יודע שכל השקופיות ו
קוד המקור הוא תמיד באינטרנט.

16
00:00:45,710 --> 00:00:50,810
אז תרגיש חופשי, בעיון שלך, ל
לחזור ותסתכלו על זה.

17
00:00:50,810 --> 00:00:53,930
>> נלך דרך
סימון אסימפטוטי, ש

18
00:00:53,930 --> 00:00:55,944
הוא רק דרך מפוארת
לומר "runtimes,"

19
00:00:55,944 --> 00:00:58,360
שבו יש לנו O הגדול, ש
דוד הסביר בהרצאה.

20
00:00:58,360 --> 00:01:01,550
ויש לנו גם אומגה, ש
הוא זמן הריצה גבול התחתון.

21
00:01:01,550 --> 00:01:06,450
ונדבר קצת יותר
בנוגע לאופן עבודה אלה לעומק.

22
00:01:06,450 --> 00:01:10,160
ולבסוף, נלך על החיפוש בינארי,
כי הרבה מכם שכבר

23
00:01:10,160 --> 00:01:15,190
הביט בpsets שלך כנראה יודע ש
זו שאלה שהוא בpset.

24
00:01:15,190 --> 00:01:17,470
אז כולכם יהיה מאושר
כי אנחנו מכסים את זה היום.

25
00:01:17,470 --> 00:01:20,610
>> ולבסוף, לכולכם
משוב סעיף, אני באמת

26
00:01:20,610 --> 00:01:23,000
עזב כ -15 דקות ב
הסוף רק כדי לעבור על

27
00:01:23,000 --> 00:01:27,730
לוגיסטיקה של pset3, כל שאלות,
אולי קצת הדרכה, אם תרצה,

28
00:01:27,730 --> 00:01:28,990
לפני שאנחנו מתחילים בתכנות.

29
00:01:28,990 --> 00:01:30,890
אז בואו ננסה לעבור את
החומר די מהר.

30
00:01:30,890 --> 00:01:33,880
ואז אנחנו יכולים להקדיש זמן
לוקח יותר שאלות לpset.

31
00:01:33,880 --> 00:01:35,230
אוקיי.

32
00:01:35,230 --> 00:01:39,570
>> במהירות, כך רק כמה
הודעות לפני שאנחנו מתחילות היום.

33
00:01:39,570 --> 00:01:45,410
ראשית, ברכה לעשיית
זה דרך שני psets.

34
00:01:45,410 --> 00:01:49,432
לקחתי מבט כן, בואו your--
תקבל מחיאות כפות לזה.

35
00:01:49,432 --> 00:01:51,140
למעשה, הייתי באמת,
מאוד התרשמתי.

36
00:01:51,140 --> 00:01:55,800
אני מדורג pset הראשון בשבילכם
בחורים בשבוע שעברו ועשו מדהימים.

37
00:01:55,800 --> 00:01:58,290
>> סגנון היה בנקודה
חוץ מכמה הערות.

38
00:01:58,290 --> 00:02:00,660
ודא שאתה תמיד
להעיר את הקוד שלך.

39
00:02:00,660 --> 00:02:03,040
אבל psets היו בנקודה.

40
00:02:03,040 --> 00:02:05,549
ולשמור אותו.

41
00:02:05,549 --> 00:02:08,090
וזה טוב לכיתה ל
רואה שאתם מכניסים

42
00:02:08,090 --> 00:02:10,704
בכמה שיותר מאמץ בסגנון שלך
והעיצוב שלך בקוד שלך

43
00:02:10,704 --> 00:02:12,120
כי אנחנו רוצים שתראו.

44
00:02:12,120 --> 00:02:16,450
אז אני מעביר את תודתי
לשאר TAS.

45
00:02:16,450 --> 00:02:19,210
>> עם זאת יש
כמה שאלות לתחקר

46
00:02:19,210 --> 00:02:22,010
אני רק רוצה ללכת על זה
תעשה שני החיים שלי

47
00:02:22,010 --> 00:02:24,900
והרבה האחרים
TAS "חי קצת יותר קל.

48
00:02:24,900 --> 00:02:28,220
זה ראשית, אני כבר שמתי לב
העבר week-- כמה מכם

49
00:02:28,220 --> 00:02:32,301
כבר פועל check50 ב
הקוד שלך לפני שאתה שולח?

50
00:02:32,301 --> 00:02:32,800
אוקיי.

51
00:02:32,800 --> 00:02:36,690
אז כולם צריך לעשות check50,
שום-- secret-- אנחנו באמת

52
00:02:36,690 --> 00:02:41,540
לרוץ check50 כחלק מהנכונות שלנו
תסריטים לבדיקת הקוד שלך.

53
00:02:41,540 --> 00:02:45,480
אז אם הקוד שלך נכשל
check50, ככל הנראה,

54
00:02:45,480 --> 00:02:47,570
זה כנראה הולך ל
להיכשל הבדיקה שלנו גם כן.

55
00:02:47,570 --> 00:02:49,320
לפעמים אתם
יש את התשובות הנכונות.

56
00:02:49,320 --> 00:02:52,200
כמו, בחמדני, חלק מ
יש לך את המספרים הנכונים,

57
00:02:52,200 --> 00:02:53,960
אתה רק להדפיס כמה דברים מיותרים.

58
00:02:53,960 --> 00:02:55,940
וכי דברים מיותרים
למעשה נכשל הבדיקה,

59
00:02:55,940 --> 00:02:58,440
כי המחשב אינו
באמת יודע מה שהוא מחפש.

60
00:02:58,440 --> 00:03:00,981
וכך זה יהיה פשוט לרוץ דרך,
רואה שהתפוקה שלך לא

61
00:03:00,981 --> 00:03:03,810
תואם את מה שאנחנו מצפים את התשובה
להיות, ולסמן אותו לא בסדר.

62
00:03:03,810 --> 00:03:06,560
>> ואני יודע שקרה ב
חלק מהמקרים שלך שבוע.

63
00:03:06,560 --> 00:03:09,870
אז חזרתי וידני
regraded הקוד של כולם.

64
00:03:09,870 --> 00:03:12,780
בעתיד אם כי,
בבקשה, בבקשה לוודא

65
00:03:12,780 --> 00:03:14,570
שאתה מפעיל
לבדוק 50 בקוד שלך.

66
00:03:14,570 --> 00:03:17,970
כי זה סוג של כאב לת"א
יש לחזור וידני regrade

67
00:03:17,970 --> 00:03:21,197
כל pset לכל
מופע יחיד, קטן החמיץ.

68
00:03:21,197 --> 00:03:22,530
אז לא לקחת את כל נקודות.

69
00:03:22,530 --> 00:03:25,210
אני חושב שאני המראתי אולי
אחד או שניים לעיצוב.

70
00:03:25,210 --> 00:03:27,710
בעתיד אם כי, אם
אתה נכשל check50,

71
00:03:27,710 --> 00:03:31,330
נקודות תילקח
את התקינות.

72
00:03:31,330 --> 00:03:35,020
>> יתר על כן, הם psets
בשל ימי שישי בצהריים.

73
00:03:35,020 --> 00:03:38,990
אני חושב שיש שבע דקות
תקופת חסד מאוחר שאנחנו נותנים לך.

74
00:03:38,990 --> 00:03:42,434
לזמן הרווארד, הם אפשרו ל
שבע דקות מאוחר לכל דבר.

75
00:03:42,434 --> 00:03:44,350
אז הנה באוניברסיטת ייל, אנחנו
לדבוק זה גם כן.

76
00:03:44,350 --> 00:03:47,910
אבל פחות או יותר, ב12:07,
אם pset שלך הוא לא ב,

77
00:03:47,910 --> 00:03:49,720
זה הולך להיות מסומן כשלהי.

78
00:03:49,720 --> 00:03:53,160
וכך בזמן שהוא מסומן
מאוחר, אני TA--

79
00:03:53,160 --> 00:03:54,870
עדיין הולך להיות לדירוג psets.

80
00:03:54,870 --> 00:03:56,760
אז אתה עדיין רואה כיתה מופיעה.

81
00:03:56,760 --> 00:03:58,820
עם זאת, יודע שב
סוף הסמסטר,

82
00:03:58,820 --> 00:04:02,270
כל psets מאוחר רק יהיה
מאופס באופן אוטומטי על ידי המחשב.

83
00:04:02,270 --> 00:04:04,490
>> אנו עושים זאת משתי סיבות.

84
00:04:04,490 --> 00:04:09,220
אחד, לפעמים אנחנו מקבלים
סליחה, כמו התירוצים של הדיקן,

85
00:04:09,220 --> 00:04:10,762
בשלב מאוחר יותר שאני לא יודע על עדיין.

86
00:04:10,762 --> 00:04:13,761
אז אנחנו רוצים לוודא שאנחנו דירוג
כל מה שרק במקרה, כמו, אני

87
00:04:13,761 --> 00:04:15,080
חסר התירוץ של דיקן.

88
00:04:15,080 --> 00:04:17,000
ושנית, לשמור ב
דעתך, אתה עדיין יכול

89
00:04:17,000 --> 00:04:19,370
טיפת pset אחד ש
יש נקודות היקף מלאה.

90
00:04:19,370 --> 00:04:21,430
וכך אנו רוצים כיתה
כל psets רק

91
00:04:21,430 --> 00:04:24,730
לוודא כי ההיקף שלך של
שם ואתה מנסה אותם.

92
00:04:24,730 --> 00:04:29,150
אז גם אם זה מאוחר, אתה עדיין
תקבל נקודות היקף אשראי, אני חושב.

93
00:04:29,150 --> 00:04:33,730
>> אז מוסר השכל של הסיפור הוא, לעשות
בטוח psets נמצא בב-זמן.

94
00:04:33,730 --> 00:04:38,350
ואם הם לא בב-זמן,
יודע שזה לא גדול.

95
00:04:38,350 --> 00:04:41,678
כן, לפני שאני ממשיך הלאה, למישהו יש
שאלות בנוגע למשוב pset?

96
00:04:41,678 --> 00:04:42,178
כן.

97
00:04:42,178 --> 00:04:43,630
>> קהל: אתה אומר ש
יכול להוריד אחד psets?

98
00:04:43,630 --> 00:04:44,296
>> ANDI פנג: כן.

99
00:04:44,296 --> 00:04:47,050
אז יש תשע psets כולל
במהלך הסמסטר.

100
00:04:47,050 --> 00:04:50,610
ואם יש לך היקף
points-- כך היקף הוא פשוט,

101
00:04:50,610 --> 00:04:53,567
די הרבה, אתה מנסה
בעיה, אתה מניח בזמן,

102
00:04:53,567 --> 00:04:56,150
אתה מראה שיש לך
הוכחנו שקראת את המפרט.

103
00:04:56,150 --> 00:04:57,191
זה פחות או יותר היקף.

104
00:04:57,191 --> 00:04:59,370
ואם אתה ממלא
נקודות היקף, ש

105
00:04:59,370 --> 00:05:03,360
יכול לרדת הנמוך ביותר
אחד מתוך היקף מלא.

106
00:05:03,360 --> 00:05:06,790
אז זה ביתרון שלך ל
להשלים ולנסות כל pset.

107
00:05:06,790 --> 00:05:10,320
>> אפילו upload-- אם אף אחד מ
להם לעבוד, להעלות את כולם.

108
00:05:10,320 --> 00:05:13,711
ואז אני מקווה שנוכל
אתן לך כמה הנקודות האלה בחזרה.

109
00:05:13,711 --> 00:05:14,210
מגניב.

110
00:05:14,210 --> 00:05:16,780
כל שאלות אחרות?

111
00:05:16,780 --> 00:05:17,840
גדול.

112
00:05:17,840 --> 00:05:21,960
>> שנית, משרד hours-- כמה
הערות מהירות על שעתי עבודה.

113
00:05:21,960 --> 00:05:24,300
אז קודם כל, בואו בתחילת השבוע.

114
00:05:24,300 --> 00:05:26,909
אף אחד לא אי פעם ב
שעתי עבודה בימים שני.

115
00:05:26,909 --> 00:05:28,700
קריסטבל הגיע ל
שעתי עבודה בלילה אחרון.

116
00:05:28,700 --> 00:05:29,691
כן, קריסטבל.

117
00:05:29,691 --> 00:05:32,190
ומה היה לנו במשרד
שעות אתמול בלילה, קריסטבל?

118
00:05:32,190 --> 00:05:33,020
>> קהל: היו לנו גלידה.

119
00:05:33,020 --> 00:05:36,160
>> ANDI פנג: אז זה נכון, היה לנו
גלידה בשעתי עבודה בלילה אחרון.

120
00:05:36,160 --> 00:05:39,390
למרות שאני לא יכול להבטיח לך ש
תהיה לנו גלידה בשעתי עבודה

121
00:05:39,390 --> 00:05:43,230
בכל שבוע, מה שאני יכול להבטיח לך
הוא שלא יהיה באופן משמעותי

122
00:05:43,230 --> 00:05:45,380
תלמיד טוב יותר ליחס ת"א.

123
00:05:45,380 --> 00:05:47,650
כמו לגיטימי, זה כמו שלוש לאחד.

124
00:05:47,650 --> 00:05:50,350
ואילו, בניגוד שעם
יום חמישי, יש לך על 150

125
00:05:50,350 --> 00:05:52,830
באמת הדגיש ילדים ולא גלידה.

126
00:05:52,830 --> 00:05:55,360
וזה פשוט לא יעיל לכל אחד.

127
00:05:55,360 --> 00:05:58,730
אז מוסר השכל של הסיפור הוא, להגיע מוקדם
לשעתי עבודה ודברים טובים

128
00:05:58,730 --> 00:06:00,310
יקרה.

129
00:06:00,310 --> 00:06:02,110
>> כמו כן, לבוא מוכן לשאול שאלות.

130
00:06:02,110 --> 00:06:03,200
אתה יודע?

131
00:06:03,200 --> 00:06:05,420
לא משנה מה TAS, אני
חושב, כבר אמר,

132
00:06:05,420 --> 00:06:10,710
אנחנו כבר מקבלים זוג סטודנטים
שבאים ביום חמישי ב, כמו, 10:50

133
00:06:10,710 --> 00:06:15,100
שלא לקרוא את המפרט
להיות כמו לעזור לי, תעזור לי.

134
00:06:15,100 --> 00:06:18,200
למרבה הצער, בשלב זה, יש
לא הרבה שאנחנו יכולים לעשות כדי לעזור לך.

135
00:06:18,200 --> 00:06:19,590
אז בבקשה לבוא בתחילת השבוע.

136
00:06:19,590 --> 00:06:22,040
הגיע מוקדם לשעתי עבודה.

137
00:06:22,040 --> 00:06:23,350
בואו מוכן לשאול שאלות.

138
00:06:23,350 --> 00:06:25,310
ודא כי אתה, כ
סטודנט, הם שבו

139
00:06:25,310 --> 00:06:27,620
אתה צריך להיות כדי ש
TAS יכול להדריך אותך לאורך,

140
00:06:27,620 --> 00:06:32,850
וזה מה ששעתי עבודה
צריך להיות מוקצה ל.

141
00:06:32,850 --> 00:06:37,380
>> שנית, אז אני יודע פרופסורים
רוצה להפתיע אותנו עם בדיקות.

142
00:06:37,380 --> 00:06:39,439
היה לי פרופסור אלה
כמו, יו, אגב,

143
00:06:39,439 --> 00:06:41,230
זוכר אמצע קדנציה ש
יש לך ביום שני הבא.

144
00:06:41,230 --> 00:06:42,855
כן, אני לא יודע על אמצע קדנציה ש.

145
00:06:42,855 --> 00:06:45,630
אז אני הולך להיות שת"א
שמזכיר לך את כל חידון ש

146
00:06:45,630 --> 00:06:47,270
0-- כי, אתה יודע, אנחנו CS.

147
00:06:47,270 --> 00:06:50,730
עכשיו שיש לנו מערכים לעשות, אתה מקבל
למה זה חידון 0, לא לבחון את 1, אה?

148
00:06:50,730 --> 00:06:51,320
אוקיי.

149
00:06:51,320 --> 00:06:52,490
אה, יש לי כמה גיחוכים על זה.

150
00:06:52,490 --> 00:06:53,120
אוקיי.

151
00:06:53,120 --> 00:06:59,710
>> אז חידון 0 יהיה 14 אוקטובר אם
אתה בקטע יום שני, רביעי

152
00:06:59,710 --> 00:07:02,920
ל -15 באוקטובר, אם אתה ב
סעיף יום שלישי יום חמישי.

153
00:07:02,920 --> 00:07:05,630
זה אינו חל על
אלו מכם בהרווארד

154
00:07:05,630 --> 00:07:10,350
who-- אני חושב שכולכם אהיה
לוקח החידונים שלך על ה -14.

155
00:07:10,350 --> 00:07:13,560
>> אז כן, בשבוע הבא, אם
דוד, בהרצאה, הולך,

156
00:07:13,560 --> 00:07:15,747
כן, כך על זה
בשבוע הבא חידון, כל מה שאתה

157
00:07:15,747 --> 00:07:17,580
לא להזדעזע בגלל
אתה בא לסעיף

158
00:07:17,580 --> 00:07:19,664
ואתה יודע ש
חידון 0 הוא בשבועות.

159
00:07:19,664 --> 00:07:21,580
ויהיה לנו סקירה
הפעלות והכל.

160
00:07:21,580 --> 00:07:26,360
אז אינו דואג
לפחד של.

161
00:07:26,360 --> 00:07:29,890
כל שאלות before-- כל שאלות
בכל הנושאים הלוגיסטיים הנוגעים,

162
00:07:29,890 --> 00:07:32,591
דירוג, שעתי עבודה, חלקים?

163
00:07:32,591 --> 00:07:33,090
כן.

164
00:07:33,090 --> 00:07:35,100
>> קהל: אז החידון הוא
הולך להיות במהלך הרצאה?

165
00:07:35,100 --> 00:07:35,766
>> ANDI פנג: כן.

166
00:07:35,766 --> 00:07:39,460
אז החידון, אני חושב, הוא 60
דקות שהוקצו שבמשבצת הזמן

167
00:07:39,460 --> 00:07:42,240
שרק תיקח
באולם ההרצאות.

168
00:07:42,240 --> 00:07:44,810
אז אתה לא צריך לבוא ב
ב, כמו, 19:00 אקראיים.

169
00:07:44,810 --> 00:07:46,140
הכל טוב.

170
00:07:46,140 --> 00:07:47,100
כן.

171
00:07:47,100 --> 00:07:50,060
מגניב.

172
00:07:50,060 --> 00:07:50,840
>> בסדר.

173
00:07:50,840 --> 00:07:54,330
אז אנחנו הולכים ל
להציג את רעיון של

174
00:07:54,330 --> 00:08:00,760
השבוע שיש דוד כבר סוג
של נגע בהרצאה בשבוע שעבר.

175
00:08:00,760 --> 00:08:02,010
זה נקרא GDB.

176
00:08:02,010 --> 00:08:05,570
וכמה מכם, ואילו ב
במהלך כתיבת psets,

177
00:08:05,570 --> 00:08:09,981
שמת לב שכפתור גדול אומר
"Debug" בחלק העליון של IDE שלך?

178
00:08:09,981 --> 00:08:10,480
אוקיי.

179
00:08:10,480 --> 00:08:13,770
אז עכשיו אנחנו באמת נקבל לחשוף
המסתורין של מה כפתור שלמעשה

180
00:08:13,770 --> 00:08:14,270
עושה.

181
00:08:14,270 --> 00:08:16,790
ואני מבטיח לך, זה
דבר יפה, יפה.

182
00:08:16,790 --> 00:08:20,740
>> אז עד עכשיו, אני חושב ש
יש כבר שני דברים

183
00:08:20,740 --> 00:08:23,320
תלמידים היו בדרך כלל
עושה כאשר באגים psets.

184
00:08:23,320 --> 00:08:27,635
אחד, הם גם להוסיף ב
printf () - כך כל כמה שורות,

185
00:08:27,635 --> 00:08:29,760
הם מוסיפים בprintf () -
הו, מה הוא משתנה זה?

186
00:08:29,760 --> 00:08:32,551
הו, מה הוא משתנה זה now--
ואתה סוג של לראות את ההתקדמות

187
00:08:32,551 --> 00:08:33,940
הקוד שלך כפי שהוא פועל.

188
00:08:33,940 --> 00:08:37,030
או השיטה השנייה ילדים לעשות היא
כי הם פשוט לכתוב את כל העניין

189
00:08:37,030 --> 00:08:38,610
ואז ללכת ככה בסוף.

190
00:08:38,610 --> 00:08:39,970
אני מקווה שזה עובד.

191
00:08:39,970 --> 00:08:44,851
אני מבטיח לך, GDB הוא טוב יותר
משתי שיטות אלה.

192
00:08:44,851 --> 00:08:45,350
כן.

193
00:08:45,350 --> 00:08:46,980
אז זה יהיה החבר הכי טוב שלך החדש.

194
00:08:46,980 --> 00:08:51,780
כי זה דבר יפה
כי מבחינה ויזואלית מציג שני

195
00:08:51,780 --> 00:08:54,850
מה הקוד שלך עושה
בנקודה מסוימת

196
00:08:54,850 --> 00:08:57,486
כמו גם מה שכולכם
משתנים נושאים,

197
00:08:57,486 --> 00:08:59,610
כמו מה הם הערכים שלהם,
שבנקודה מסוימת.

198
00:08:59,610 --> 00:09:02,670
ובדרך זו, אתה באמת יכול
להגדיר נקודות עצירה בקוד שלך.

199
00:09:02,670 --> 00:09:04,350
אתה יכול לרוץ דרך שורה אחרת שורה.

200
00:09:04,350 --> 00:09:07,324
וGDB רק צריך ל
אתה, מוצג לך,

201
00:09:07,324 --> 00:09:09,490
מה כל המשתנים שלך
הם, מה הם עושים,

202
00:09:09,490 --> 00:09:10,656
מה קורה בקוד.

203
00:09:10,656 --> 00:09:13,240
ובאופן כזה, זה
כך הרבה יותר קל לראות

204
00:09:13,240 --> 00:09:17,120
מה שקורה במקום printf-ing
או לכתוב את הדברים שלך.

205
00:09:17,120 --> 00:09:19,160
>> אז אנחנו נעשה את דוגמא לכך בהמשך.

206
00:09:19,160 --> 00:09:20,660
אז זה נראה קצת מופשט.

207
00:09:20,660 --> 00:09:23,490
אין דאגות, אנחנו נעשה את דוגמאות.

208
00:09:23,490 --> 00:09:29,170
וכך בעצם, שלוש גדול,
ביותר בשימוש בפונקציות שאתה צריך בGDB

209
00:09:29,170 --> 00:09:32,500
הם בשלב הבא, שלב מעל,
וצעד ​​לתוך כפתורים.

210
00:09:32,500 --> 00:09:34,860
אני הולך מעל הראש
יש, למעשה, עכשיו.

211
00:09:34,860 --> 00:09:40,930
>> אז אתם יכולים לראות את כל ש
או שאני צריך להתמקד במעט?

212
00:09:40,930 --> 00:09:43,220

213
00:09:43,220 --> 00:09:44,470
בחלק האחורי, אתה יכול לראות את זה?

214
00:09:44,470 --> 00:09:45,730
אני צריך להתמקד ב?

215
00:09:45,730 --> 00:09:46,480
רק קצת?

216
00:09:46,480 --> 00:09:49,390
בסדר מגניב.

217
00:09:49,390 --> 00:09:50,280
הנה.

218
00:09:50,280 --> 00:09:50,960
אוקיי.

219
00:09:50,960 --> 00:09:57,000
>> אז יש לי, כאן, שלי
יישום לחמדנים.

220
00:09:57,000 --> 00:10:01,430
ובעוד הרבה אתם כתבו
חמדן בבעוד לולאה form-- ש

221
00:10:01,430 --> 00:10:04,890
היא דרך מקובלת לחלוטין לעשות
it-- עוד דרך לעשות את זה הוא פשוט

222
00:10:04,890 --> 00:10:06,280
לחלק במודולו.

223
00:10:06,280 --> 00:10:09,290
כי אז אתה יכול לקבל את שלך
ערך ואז יש לך היתרה.

224
00:10:09,290 --> 00:10:11,150
ואז אתה פשוט יכול
להוסיף את כל זה ביחד.

225
00:10:11,150 --> 00:10:13,390
האם ההיגיון של מה שאני עושה
כאן הגיוני לכולם,

226
00:10:13,390 --> 00:10:14,117
לפני שתתחילו?

227
00:10:14,117 --> 00:10:16,760

228
00:10:16,760 --> 00:10:17,980
בערך?

229
00:10:17,980 --> 00:10:18,710
מגניב.

230
00:10:18,710 --> 00:10:19,210
גדול.

231
00:10:19,210 --> 00:10:21,290
זה חתיכה יפה סקסית
של קוד, הייתי אומר.

232
00:10:21,290 --> 00:10:23,502
כמו שאמרתי, דוד, ב
הרצאה, אחרי כמה זמן,

233
00:10:23,502 --> 00:10:25,960
כל מה שאתה תתחיל לראות קוד
כמשהו שהוא יפה.

234
00:10:25,960 --> 00:10:29,950
ולפעמים כשאתה רואה יפה
קוד, זו תחושה כל כך נפלאה.

235
00:10:29,950 --> 00:10:35,410
>> אז עם זאת, בעוד שהקוד הזה הוא מאוד
יפה, זה לא עובד כמו שצריך.

236
00:10:35,410 --> 00:10:37,750
אז בואו לרוץ check50 על זה.

237
00:10:37,750 --> 00:10:39,440
בדוק 50 20-- OOP.

238
00:10:39,440 --> 00:10:43,221

239
00:10:43,221 --> 00:10:43,720
2?

240
00:10:43,720 --> 00:10:44,990
האם pset2 ש?

241
00:10:44,990 --> 00:10:46,870
כן.

242
00:10:46,870 --> 00:10:47,520
אה, pset1.

243
00:10:47,520 --> 00:10:50,970

244
00:10:50,970 --> 00:10:52,890
אוקיי.

245
00:10:52,890 --> 00:10:53,900
אז אנחנו רצים check50.

246
00:10:53,900 --> 00:11:01,550

247
00:11:01,550 --> 00:11:07,170
>> וכמו שאתם יכולים לראות כאן,
זה נכשל כמה מקרים.

248
00:11:07,170 --> 00:11:10,165
ועבור חלק מכם, ב
כמובן לעשות סטי הבעיה שלך,

249
00:11:10,165 --> 00:11:11,110
אתה כמו, אה, למה זה לא עובד.

250
00:11:11,110 --> 00:11:13,318
למה זה עובד עבור חלק
ערכים אך לא לאחרים?

251
00:11:13,318 --> 00:11:17,760
ובכן, GDB הוא הולך לעזור לך דמות
מדוע תשומות אלה לא עבדו.

252
00:11:17,760 --> 00:11:18,320
>> אוקיי.

253
00:11:18,320 --> 00:11:21,640
אז בואו לראות, אחד מ
בדיקות שנכשלתי בcheck50

254
00:11:21,640 --> 00:11:24,920
היה ערך הקלט של 0.41.

255
00:11:24,920 --> 00:11:27,830
אז את התשובה הנכונה ש
אתה צריך לקבל הוא 4.

256
00:11:27,830 --> 00:11:33,090
אבל במקום מה שאני מדפיס את
הוא 3-n, שאינו נכון.

257
00:11:33,090 --> 00:11:36,190
אז בואו פשוט להפעיל את זה באופן ידני, רק
לוודא שcheck50 עובד.

258
00:11:36,190 --> 00:11:36,940
בואו לעשות ./greedy.

259
00:11:36,940 --> 00:11:40,130

260
00:11:40,130 --> 00:11:43,340
אופס, אני צריך לעשות חמדנים.

261
00:11:43,340 --> 00:11:43,840
הנה.

262
00:11:43,840 --> 00:11:44,381
עכשיו ./greedy.

263
00:11:44,381 --> 00:11:46,950

264
00:11:46,950 --> 00:11:47,670
>> כמה הוא חייב?

265
00:11:47,670 --> 00:11:49,550
בואו לעשות 0.41.

266
00:11:49,550 --> 00:11:52,590
וכן, אנחנו רואים כאן
שזה פלט 3

267
00:11:52,590 --> 00:11:55,160
כאשר התשובה הנכונה,
למעשה, צריך להיות 4.

268
00:11:55,160 --> 00:12:01,460
אז בואו להיכנס GDB ולראות איך אנחנו
יכול ללכת על תיקון בעיה זו.

269
00:12:01,460 --> 00:12:03,992
>> אז הצעד הראשון ב
תמיד באגים הקוד שלך

270
00:12:03,992 --> 00:12:05,950
הוא לקבוע נקודת עצירה,
או נקודה שבה אתה

271
00:12:05,950 --> 00:12:09,079
רוצה את המחשב או
הבאגים להתחיל להסתכל.

272
00:12:09,079 --> 00:12:11,120
אז אם אתה לא באמת
יודע מה הבעיה שלך,

273
00:12:11,120 --> 00:12:14,670
בדרך כלל, הדבר האופייני אנחנו רוצים
לעשות הוא להגדיר נקודת העצירה שלנו בעיקרי.

274
00:12:14,670 --> 00:12:18,520
אז אם אתם יכולים לראות את זה
כפתור אדום ממש שם,

275
00:12:18,520 --> 00:12:22,860
כן, זה היה לי הגדרה
נקודת עצירה לפונקציה העיקרית.

276
00:12:22,860 --> 00:12:24,130
אני לוחץ ש.

277
00:12:24,130 --> 00:12:26,130
>> ואז אני יכול ללכת עד כפתור Debug שלי.

278
00:12:26,130 --> 00:12:27,036
אני מכה על כפתור ש.

279
00:12:27,036 --> 00:12:31,710

280
00:12:31,710 --> 00:12:36,555
תן לי להתקרב בחזרה אם אני יכול.

281
00:12:36,555 --> 00:12:38,020
הנה.

282
00:12:38,020 --> 00:12:40,730
אז יש לנו, כאן, בלוח בצד הימין.

283
00:12:40,730 --> 00:12:43,680
אני מצטער, חבר 'בגב, אתה
לא באמת יכול לראות ממש טוב.

284
00:12:43,680 --> 00:12:49,090
אבל בעצם, כל
פנל זכות זו עושה

285
00:12:49,090 --> 00:12:53,130
הוא שמירה על המסלול של שני מודגשים
קו, שהוא הקו של קוד

286
00:12:53,130 --> 00:12:56,640
שהמחשב פועל כעת,
כמו גם את כל המשתנים שלך

287
00:12:56,640 --> 00:12:57,600
כאן למטה.

288
00:12:57,600 --> 00:13:00,487
>> אז יש לך סנט, מטבעות, n,
כל הוכרז דברים שונים

289
00:13:00,487 --> 00:13:01,070
בנקודה זו.

290
00:13:01,070 --> 00:13:04,850
אין דאגות, כי יש לנו לא ממש
אותחל אותם לכל משתנים עדיין.

291
00:13:04,850 --> 00:13:07,200
אז במחשב שלך, שלך
מחשב פשוט לראות,

292
00:13:07,200 --> 00:13:14,376
הו, 32767 הייתה הפונקציה האחרונה בשימוש
של אותו מרחב זיכרון במחשב שלי.

293
00:13:14,376 --> 00:13:16,000
ואז זה שבו סנט הוא כיום.

294
00:13:16,000 --> 00:13:19,360
אבל לא כי ברגע שאתה מפעיל את הקוד,
זה צריך להיות מאותחל.

295
00:13:19,360 --> 00:13:24,110
>> אז בואו לעבור, קו על ידי
קו, מה שקורה כאן.

296
00:13:24,110 --> 00:13:25,350
אוקיי.

297
00:13:25,350 --> 00:13:29,400
אז עד כאן הם שלוש
כפתורים שאני רק הסברתי.

298
00:13:29,400 --> 00:13:34,090
יש לך לשחק, או פונקצית הפעלה,
כפתור, יש לך את שלב על כפתור,

299
00:13:34,090 --> 00:13:36,600
וגם יש לך את הצעד לתוך כפתור.

300
00:13:36,600 --> 00:13:41,260
ובעצם, כל שלושת
שלהם רק לעבור את הקוד שלך

301
00:13:41,260 --> 00:13:42,690
ולעשות דברים שונים.

302
00:13:42,690 --> 00:13:45,680
>> אז בדרך כלל, כשאתה באגים,
אנחנו לא רוצים רק לפגוע Play,

303
00:13:45,680 --> 00:13:47,930
כי לשחק רק ירוץ
הקוד שלך בסופו של אותו.

304
00:13:47,930 --> 00:13:49,070
ואז אתה לא ממש
יודע מה הבעיה שלך

305
00:13:49,070 --> 00:13:51,432
אלא אם כן אתה הוא להגדיר נקודות עצירה מרובות.

306
00:13:51,432 --> 00:13:53,890
אם תגדירו נקודות עצירה מרובות,
זה יהיה רק ​​באופן אוטומטי

307
00:13:53,890 --> 00:13:56,030
לרוץ מנקודת עצירה אחת,
למשנהו, למשנהו.

308
00:13:56,030 --> 00:13:58,030
אבל במקרה הזה יש לנו
רק שאחד, כי אנחנו

309
00:13:58,030 --> 00:13:59,970
רוצה לעבוד בדרך שלנו
מלמעלה למטה לתחתית.

310
00:13:59,970 --> 00:14:04,830
אז אנחנו הולכים להתעלם כפתור ש
עכשיו למטרות של תכנית זו.

311
00:14:04,830 --> 00:14:08,230
>> אז שלב מעל הפונקציה רק
צעדים על כל קו

312
00:14:08,230 --> 00:14:11,510
ואומר לך מה
המחשב עושה.

313
00:14:11,510 --> 00:14:14,630
הצעד לתוך פונקציה הולך
לפונקציה בפועל

314
00:14:14,630 --> 00:14:16,000
זה בשורת הקוד שלך.

315
00:14:16,000 --> 00:14:19,070
כך למשל, כמו printf (),
שהוא פונקציה, נכון?

316
00:14:19,070 --> 00:14:21,980
אם אני רוצה צעד פיזי
לprintf () הפונקציה,

317
00:14:21,980 --> 00:14:25,610
אני דווקא הייתי הולך לחתיכה
קוד שבו printf () נכתב ותראה

318
00:14:25,610 --> 00:14:26,730
מה קורה שם.

319
00:14:26,730 --> 00:14:29,924
>> אבל בדרך כלל, אנו מניחים ש
הקוד שאנחנו נותנים לך עובד.

320
00:14:29,924 --> 00:14:31,340
אנו מניחים printf () הוא עובד.

321
00:14:31,340 --> 00:14:33,170
אנו מניחים כי GetInt () הוא עובד.

322
00:14:33,170 --> 00:14:35,170
כך שאין צורך
צעד לתוך פונקציות אלה.

323
00:14:35,170 --> 00:14:37,170
אבל אם יש פונקציות
שאתה כותב בעצמך

324
00:14:37,170 --> 00:14:39,060
שברצונך לבדוק
מה קורה,

325
00:14:39,060 --> 00:14:41,200
היית רוצה לשלב
לפונקציה ש.

326
00:14:41,200 --> 00:14:43,940
>> אז עכשיו אנחנו רק הולכים
לדרוך על פיסת קוד זה.

327
00:14:43,940 --> 00:14:44,485
אז בואו לראות.

328
00:14:44,485 --> 00:14:46,547
אה, הדפסה, "אה חי, איך
הרבה שינוי הוא חייב? "

329
00:14:46,547 --> 00:14:47,130
לא אכפת לנו.

330
00:14:47,130 --> 00:14:49,830
אנחנו יודעים שעובדים,
כך אנו דורכים עליו.

331
00:14:49,830 --> 00:14:53,290
>> אז n, שהוא לצוף ש
יש לנו initialized-- או declared--

332
00:14:53,290 --> 00:14:56,810
בחלק העליון, אנחנו עכשיו
שווה שלGetFloat ().

333
00:14:56,810 --> 00:14:57,810
אז בואו לדרוך על זה.

334
00:14:57,810 --> 00:14:59,580
ואנו רואים ב
התחתון כאן, התכנית

335
00:14:59,580 --> 00:15:03,360
הוא גרם לי לקלט ערך.

336
00:15:03,360 --> 00:15:08,580
אז בואו קלט הערך שאנחנו רוצים
כדי לבדוק כאן, שהוא 0.41.

337
00:15:08,580 --> 00:15:09,160
גדול.

338
00:15:09,160 --> 00:15:12,780
>> אז עכשיו n-- לעשות אתם רואים
כאן, בbottom-- זה

339
00:15:12,780 --> 00:15:15,140
stored-- כי אנחנו
לא מעוגל עדיין, זה

340
00:15:15,140 --> 00:15:19,540
מאוחסן בענק כזה
לצוף שהוא .4099999996,

341
00:15:19,540 --> 00:15:22,550
שהוא קרוב מספיק כדי
מטרות, עכשיו, ל0.41.

342
00:15:22,550 --> 00:15:26,090
ואז נראה בהמשך, כפי שאנו
תמשיך דורך על התכנית,

343
00:15:26,090 --> 00:15:29,850
אחרי כאן, n הפך
מעוגל והסנאט הפך 41.

344
00:15:29,850 --> 00:15:30,350
גדול.

345
00:15:30,350 --> 00:15:32,230
אז אנחנו יודעים שהעבודה של העיגול שלנו.

346
00:15:32,230 --> 00:15:34,700
אנחנו יודעים שיש לנו
מספר נכון של סנט,

347
00:15:34,700 --> 00:15:36,990
כך אנו יודעים כי זה
לא ממש הבעיה.

348
00:15:36,990 --> 00:15:40,050
>> אז אנחנו ממשיכים לדרוך
בתכנית זו.

349
00:15:40,050 --> 00:15:40,900
אנחנו הולכים כאן.

350
00:15:40,900 --> 00:15:46,139
וכך אחרי הקו הזה של קוד, ש
צריך לדעת כמה רבעונים שיש לנו.

351
00:15:46,139 --> 00:15:46,680
אנחנו דורכים על.

352
00:15:46,680 --> 00:15:52,040
ואתה רואה ש, למעשה, יש לנו אחד
רבעון מפני שנגרענו 25

353
00:15:52,040 --> 00:15:53,790
מהערך הראשוני שלנו של 41.

354
00:15:53,790 --> 00:15:55,890
ויש לנו 16 סנט לשמאלנו.

355
00:15:55,890 --> 00:15:58,830
>> האם כולם מבינים איך
תכנית דריכה דרך

356
00:15:58,830 --> 00:16:02,980
ומדוע סנט הפך כעת 16
ולמה, עכשיו, מטבעות הפכו 1?

357
00:16:02,980 --> 00:16:04,610
האם כולם הבאים היגיון זה?

358
00:16:04,610 --> 00:16:05,110
מגניב.

359
00:16:05,110 --> 00:16:07,860
אז כמו של נקודה זו,
העבודה של התכנית, נכון?

360
00:16:07,860 --> 00:16:09,797
אנחנו יודעים שזה עושה בדיוק
מה שאנחנו רוצים אותו.

361
00:16:09,797 --> 00:16:11,880
ואנחנו לא עשינו בעצם
צריך להדפיס את, אה, מה

362
00:16:11,880 --> 00:16:14,430
הוא סנט בשלב זה,
מה הוא מטבעות בשלב זה.

363
00:16:14,430 --> 00:16:17,170
>> אנחנו ממשיכים ללכת דרך התכנית.

364
00:16:17,170 --> 00:16:18,100
לדרוך מעל.

365
00:16:18,100 --> 00:16:18,620
מגניב.

366
00:16:18,620 --> 00:16:19,700
אנחנו הולכים על מטבעות.

367
00:16:19,700 --> 00:16:20,200
גדול.

368
00:16:20,200 --> 00:16:22,367
אנחנו רואים שזה לקח
את 0.10 $ עבור אגורה.

369
00:16:22,367 --> 00:16:23,450
ועכשיו יש לנו שתי מטבעות.

370
00:16:23,450 --> 00:16:25,260
זה נכון.

371
00:16:25,260 --> 00:16:31,555
>> אנחנו הולכים על פרוטות ואנו רואים
שיש לנו נשארו סנט.

372
00:16:31,555 --> 00:16:32,680
הממ, זה מוזר.

373
00:16:32,680 --> 00:16:37,540
עד כאן בתכנית, שהייתי אמור
שנגרע פרוטות שלי.

374
00:16:37,540 --> 00:16:39,400
אולי אני פשוט לא היה
עושה נכון קו ש.

375
00:16:39,400 --> 00:16:42,190
ואבוי, אתה יכול לראות
כאן, כי אנחנו יודעים

376
00:16:42,190 --> 00:16:44,360
שאנו דורכים
דרך קווים 32 ו -33,

377
00:16:44,360 --> 00:16:50,560
זה מקום שבי התכנית שלנו
שלא כדין היה משתנה לרוץ.

378
00:16:50,560 --> 00:16:55,136
אז אנחנו יכולים להסתכל ולראות, אה,
אני הפחתת סנט כאן,

379
00:16:55,136 --> 00:16:57,010
אבל אני לא ממש
הוספה לערך המטבע שלי.

380
00:16:57,010 --> 00:16:57,860
אני מוסיף לסנאט.

381
00:16:57,860 --> 00:17:00,234
ואני לא רוצה להוסיף ל
סנט, אני רוצה להוסיף למטבעות.

382
00:17:00,234 --> 00:17:05,420
אז אם אנחנו נשנה את זה למטבעות,
יש לנו תכנית עבודה.

383
00:17:05,420 --> 00:17:06,730
אני יכול לרוץ check50.

384
00:17:06,730 --> 00:17:11,063
אתה יכול פשוט לצאת מימין GDB
כאן ולאחר מכן להפעיל check50 שוב.

385
00:17:11,063 --> 00:17:11,938
אני רק יכול לעשות את זה.

386
00:17:11,938 --> 00:17:14,822

387
00:17:14,822 --> 00:17:18,480
אני צריך לעשות חמדנים.

388
00:17:18,480 --> 00:17:19,940
0.41.

389
00:17:19,940 --> 00:17:22,819
וכאן, זה הדפסה
את התשובה הנכונה.

390
00:17:22,819 --> 00:17:26,569
>> אז כפי שאתם יכולים לראות, GDB
הוא כלי חזק באמת

391
00:17:26,569 --> 00:17:29,940
כאשר יש לנו כל כך הרבה קוד
קורה ומשתנים כל כך הרבה

392
00:17:29,940 --> 00:17:32,510
שזה קשה לנו, כ
אדם, כדי לעקוב אחר.

393
00:17:32,510 --> 00:17:35,360
המחשב, בGDB
הבאגים, יש את היכולת

394
00:17:35,360 --> 00:17:37,020
כדי לעקוב אחר כל מה ש.

395
00:17:37,020 --> 00:17:40,480
אני יודע, בVisionaire, אתם כנראה
אולי פגע בכמה תקלות פילוח

396
00:17:40,480 --> 00:17:43,150
בגלל שאתה רץ
מחוץ לתחום של המערך שלך.

397
00:17:43,150 --> 00:17:46,510
בדוגמא של קיסר, זה
בדיוק מה שאני כבר מיושם כאן.

398
00:17:46,510 --> 00:17:50,060
>> אז שכחתי לבדוק
מה יקרה אם אני

399
00:17:50,060 --> 00:17:52,510
לא היה לי שני טיעוני שורת הפקודה.

400
00:17:52,510 --> 00:17:53,880
אני פשוט לא לשים בצק ש.

401
00:17:53,880 --> 00:17:57,380
ולכן אם אני מפעיל Debug-- אני מגדיר
נקודת העצירה שלי לשם.

402
00:17:57,380 --> 00:17:58,055
אני רץ Debug.

403
00:17:58,055 --> 00:18:15,880

404
00:18:15,880 --> 00:18:16,550
>> אוקיי.

405
00:18:16,550 --> 00:18:17,050
כן.

406
00:18:17,050 --> 00:18:20,350
אז בעצם, GDB היה אמור
שאמר לי שיש

407
00:18:20,350 --> 00:18:22,300
הייתה תקלת פילוח שם.

408
00:18:22,300 --> 00:18:24,883
אני לא יודע מה קורה
ממש שם, אבל כשאני רצתי אותו,

409
00:18:24,883 --> 00:18:25,590
זה עבד.

410
00:18:25,590 --> 00:18:29,410
כאשר אתה מפעיל את שורות קוד באמצעות ו
GDB אולי פתאום להפסיק אותך,

411
00:18:29,410 --> 00:18:31,540
לעלות ותראה מה היא השגיאה האדומה.

412
00:18:31,540 --> 00:18:33,930
זה יגיד לך, היי, אתה
הייתה תקלת פילוח,

413
00:18:33,930 --> 00:18:38,550
מה שאומר שאתה ניסית גישה
שטח במערך שלא היה קיים.

414
00:18:38,550 --> 00:18:39,050
כן.

415
00:18:39,050 --> 00:18:43,280
>> אז בבעיה הבאה
להגדיר את זה בשבוע, אתם

416
00:18:43,280 --> 00:18:45,600
כנראה יש לי הרבה
משתנים מרחפים.

417
00:18:45,600 --> 00:18:48,560
אתה לא הולך להיות בטוח מה
כל מה שהם אומר בשלב מסוים.

418
00:18:48,560 --> 00:18:53,560
אז GDB באמת יעזור לך בחישוב
את מה שהם כולם השווים

419
00:18:53,560 --> 00:18:55,940
ולהיות מסוגל לראות את זה מבחינה ויזואלית.

420
00:18:55,940 --> 00:19:01,995
מבולבל מישהו על איך
כל זה עובד?

421
00:19:01,995 --> 00:19:02,495
מגניב.

422
00:19:02,495 --> 00:19:10,121

423
00:19:10,121 --> 00:19:10,620
בסדר.

424
00:19:10,620 --> 00:19:14,260
אז אחרי ש, אנחנו
הולך לצלול תקין

425
00:19:14,260 --> 00:19:17,562
לארבעה שונים
סוגים של מיני לשבוע.

426
00:19:17,562 --> 00:19:19,520
כמה מכם, ראשון
מכל, לפני שאנחנו מתחילים,

427
00:19:19,520 --> 00:19:23,020
קראת את כל המפרט לpset3?

428
00:19:23,020 --> 00:19:23,824
אוקיי.

429
00:19:23,824 --> 00:19:24,740
אני גאה בך חבר '.

430
00:19:24,740 --> 00:19:29,110
זה כמו מחצית מהכיתה, ש
יותר באופן משמעותי מאשר בפעם האחרונה.

431
00:19:29,110 --> 00:19:33,950
>> אז זה נהדר, כי כש
אנחנו מדברים על התוכן

432
00:19:33,950 --> 00:19:36,170
בlecture-- או מצטער,
בsection-- אני אוהב

433
00:19:36,170 --> 00:19:38,210
להתייחס הרבה ש
בחזרה למה הוא pset

434
00:19:38,210 --> 00:19:40,210
ואיך אתה רוצה
ליישם שבpset.

435
00:19:40,210 --> 00:19:42,400
אז אם אתה בא שיש
לקרוא את המפרט, זה ימצא

436
00:19:42,400 --> 00:19:45,510
להיות הרבה יותר קל לך להבין
עליי כשאני אומר מה אני מדבר,

437
00:19:45,510 --> 00:19:48,720
הו היי, זה יכול להיות באמת
מקום טוב ליישום מסוג זה.

438
00:19:48,720 --> 00:19:52,870
אז אלו מכם שקראו את
ממפרט יודע את זה, כחלק מpset,

439
00:19:52,870 --> 00:19:54,900
אתה הולך צריך
לכתוב סוג של סוג.

440
00:19:54,900 --> 00:19:58,670
אז זה יכול להיות מאוד מועיל
להרבה מכם היום.

441
00:19:58,670 --> 00:20:01,760
>> אז נתחיל עם,
בעצם, הסוג הפשוט ביותר

442
00:20:01,760 --> 00:20:04,580
מסוג, מיון הבחירה.

443
00:20:04,580 --> 00:20:06,800
האלגוריתם האופייני ל
איך היינו הולכים על זה

444
00:20:06,800 --> 00:20:10,460
הוא-- דוד עבר את כל אלה ב
הרצאה, אז אני לנוע במהירות לאורך

445
00:20:10,460 --> 00:20:13,900
כאן-- הוא למעשה, אתה
יש מגוון של ערכים.

446
00:20:13,900 --> 00:20:17,170
ואז אתה מוצא
הערך הקטן ביותר לא ממוינים

447
00:20:17,170 --> 00:20:20,200
ואתה להחליף ערך שעם
הערך ממוין הראשון.

448
00:20:20,200 --> 00:20:22,700
ואז אתה פשוט ממשיך לחזור
עם שאר הרשימה שלך.

449
00:20:22,700 --> 00:20:25,740
>> והנה הסבר חזותי
איך זה יעבוד.

450
00:20:25,740 --> 00:20:30,460
כך למשל, אם היינו מתחיל
עם מערך של חמישה אלמנטים, מדד

451
00:20:30,460 --> 00:20:35,910
0 עד 4, עם 3, 5, 2, 6, ו -4 ערכים
ממוקם בarray-- כך עכשיו,

452
00:20:35,910 --> 00:20:38,530
אנחנו רק הולכים להניח
שהם כולם לא ממוינים

453
00:20:38,530 --> 00:20:41,130
בגלל שלא בדקנו אחר.

454
00:20:41,130 --> 00:20:44,130
>> אז איך היית סוג בחירה
עבודה היא שזה היית ראשון

455
00:20:44,130 --> 00:20:46,800
לרוץ דרך השלמות
של מערך לא ממוינים.

456
00:20:46,800 --> 00:20:49,120
זה יהיה לבחור את הערך הקטן ביותר.

457
00:20:49,120 --> 00:20:51,750
במקרה זה, 3, תקין
עכשיו, הוא הקטן ביותר.

458
00:20:51,750 --> 00:20:52,680
זה נהיה עד 5.

459
00:20:52,680 --> 00:20:55,620
לא, 5 אינם גדולים than--
או מצטער, לא פחות than-- 3.

460
00:20:55,620 --> 00:20:57,779
אז את הערך המינימאלי הוא עדיין 3.

461
00:20:57,779 --> 00:20:58,695
ואז אתה מקבל 2.

462
00:20:58,695 --> 00:21:00,990
המחשב רואה, אה, 2 הוא פחות מ -3.

463
00:21:00,990 --> 00:21:02,750
2 חייבים עכשיו להיות הערך המינימאלי.

464
00:21:02,750 --> 00:21:06,630
וכך 2 החלפות עם שהערך הראשון.

465
00:21:06,630 --> 00:21:10,702
>> אז אחרי מעבר אחד, אנחנו אכן רואים
כי 2 ו 3 הם החליפו.

466
00:21:10,702 --> 00:21:13,910
ואנחנו רק הולכים להמשיך לעשות
זה שוב עם שאר המערך.

467
00:21:13,910 --> 00:21:17,660
אז אנחנו הולכים רק כדי לרוץ דרך
ארבעת המדדים האחרונים של המערך.

468
00:21:17,660 --> 00:21:20,670
אנחנו תראו את זה 3 הוא
הערך המינימאלי הבא.

469
00:21:20,670 --> 00:21:23,240
אז אנחנו הולכים להחליף את זה עם 4.

470
00:21:23,240 --> 00:21:26,900
ואז אנחנו פשוט הולכים לשמור
פועל באמצעות עד, סופו של דבר, אתה

471
00:21:26,900 --> 00:21:33,730
להגיע למערך ממוין שבי
2, 3, 4, 5, ו -6 כולם מסודרים.

472
00:21:33,730 --> 00:21:37,530
האם כולם מבינים את ההיגיון
איך מיון בחירה עובד?

473
00:21:37,530 --> 00:21:39,669
>> רק שיש לך סוג כלשהו
של ערך מינימאלי.

474
00:21:39,669 --> 00:21:41,210
אתה עוקב אחרי מה ש.

475
00:21:41,210 --> 00:21:45,170
וכל פעם שאתה מוצא את זה, אתה להחליף אותו
עם הערך הראשון בarray--

476
00:21:45,170 --> 00:21:48,740
או, לא value-- הראשון
הערך הבא במערך.

477
00:21:48,740 --> 00:21:50,150
מגניב.

478
00:21:50,150 --> 00:21:55,460
>> כאתם כל כך סוג של
ראה ממבט חטוף,

479
00:21:55,460 --> 00:21:58,450
אנחנו הולכים לפסאודו קוד את זה.

480
00:21:58,450 --> 00:22:02,510
אז אם אתם בגב רוצים
ליצור קבוצה, כולם בשולחן

481
00:22:02,510 --> 00:22:06,170
יכול ליצור קצת שותף, אני הולך
לתת לכם כמו שלוש דקות

482
00:22:06,170 --> 00:22:08,190
רק כדי לדבר דרך
ההיגיון, באנגלית,

483
00:22:08,190 --> 00:22:14,161
איך אנחנו יכולים להיות מסוגלים ליישם
פסאודו קוד לכתוב מיון בחירה.

484
00:22:14,161 --> 00:22:14,910
ויש ממתקים.

485
00:22:14,910 --> 00:22:16,118
נא לבוא ולקבל ממתקים.

486
00:22:16,118 --> 00:22:19,520
אם אתה בגב ואתה רוצה
סוכריות, אני יכול לזרוק סוכריות עליך.

487
00:22:19,520 --> 00:22:22,850
למעשה, לעשות מגניב אתם--.

488
00:22:22,850 --> 00:22:23,552
אה סליחה.

489
00:22:23,552 --> 00:22:26,751

490
00:22:26,751 --> 00:22:27,250
אוקיי.

491
00:22:27,250 --> 00:25:23,880

492
00:25:23,880 --> 00:25:27,140
>> אז אם אנחנו רוצים, כ
כיתה, פסאודו קוד כתיבה

493
00:25:27,140 --> 00:25:30,466
איך אפשר להתקרב
בעיה זו, פשוט מרגישה חופשית.

494
00:25:30,466 --> 00:25:32,340
אני רק אלך מסביב ו,
כדי, לשאול קבוצות

495
00:25:32,340 --> 00:25:35,065
לשורה הבאה של
מה שאנחנו צריכים לעשות.

496
00:25:35,065 --> 00:25:37,840
אז אם אתם רוצים להתחיל
את, מה הדבר הראשון

497
00:25:37,840 --> 00:25:40,600
לעשות כאשר אתה מנסה
ליישם דרך לפתור תכנית זו

498
00:25:40,600 --> 00:25:43,480
למיין באופן סלקטיבי רשימה?

499
00:25:43,480 --> 00:25:46,349
בואו פשוט להניח לנו
יש מערך, בסדר?

500
00:25:46,349 --> 00:25:49,088
>> קהל: אתה רוצה ליצור כמה
סוג של [לא ברור] שאתה

501
00:25:49,088 --> 00:25:50,420
פועל באמצעות המערך השלם שלך.

502
00:25:50,420 --> 00:25:51,128
>> ANDI פנג: ימין.

503
00:25:51,128 --> 00:25:54,100
אז אתה הולך רוצה לחזר
דרך כל שטח, נכון?

504
00:25:54,100 --> 00:26:05,490
כל כך גדול.

505
00:26:05,490 --> 00:26:08,600
אם אתם רוצים לתת לי
הבא line-- כן, בחלק האחורי.

506
00:26:08,600 --> 00:26:11,414

507
00:26:11,414 --> 00:26:13,290
>> קהל: בדוק אותם
כל לקטן ביותר.

508
00:26:13,290 --> 00:26:14,248
>> ANDI פנג: יש לנו ללכת.

509
00:26:14,248 --> 00:26:17,438
אז אנחנו רוצים לעבור ולבדוק ל
לראות מה הוא הערך המינימאלי, נכון?

510
00:26:17,438 --> 00:26:22,110

511
00:26:22,110 --> 00:26:24,840
אני הולך לקצר כי ל" דק ".

512
00:26:24,840 --> 00:26:27,658
מה אתם רוצים לעשות אחרי
אתה כבר נמצא את הערך המינימאלי?

513
00:26:27,658 --> 00:26:28,533
>> קהל: [לא ברור]

514
00:26:28,533 --> 00:26:29,942

515
00:26:29,942 --> 00:26:33,150
ANDI פנג: אז אתה הולך רוצה
לעבור את זה עם הראשון של מערך זה,

516
00:26:33,150 --> 00:26:33,650
נכון?

517
00:26:33,650 --> 00:26:45,120

518
00:26:45,120 --> 00:26:46,850
זה ההתחלה, אני הולך לומר.

519
00:26:46,850 --> 00:26:47,220
בסדר.

520
00:26:47,220 --> 00:26:50,386
אז עכשיו שאתה כבר החליף ראשון
אחד, מה אתה רוצה לעשות אחרי זה?

521
00:26:50,386 --> 00:26:54,840
אז עכשיו אנחנו יודעים שזה אחד כאן
חייב להיות הערך הקטן ביותר, נכון?

522
00:26:54,840 --> 00:26:58,310
אז יש לך מנוחה נוספת
של המערך זה לא ממוינים.

523
00:26:58,310 --> 00:27:01,569
אז מה אתה רוצה לעשות כאן, אם אתה
אתם רוצים לתת לי את השורה הבאה?

524
00:27:01,569 --> 00:27:04,610
קהל: אז אתה רוצה לחזר
דרך שארית המערך.

525
00:27:04,610 --> 00:27:05,276
ANDI פנג: כן.

526
00:27:05,276 --> 00:27:09,857
ואז מה iterating דרך
סוג של לרמוז אנחנו כנראה נצטרך?

527
00:27:09,857 --> 00:27:10,440
איזה סוג ל--

528
00:27:10,440 --> 00:27:12,057
>> קהל: הו, משתנה נוסף?

529
00:27:12,057 --> 00:27:13,890
ANDI פנג: כנראה
נוסף ללולאה, נכון?

530
00:27:13,890 --> 00:27:28,914
אז אנחנו כנראה הולכים רוצים
ללחזר through-- גדול.

531
00:27:28,914 --> 00:27:31,830
ואז אתה הולך לחזור ו
כנראה לבדוק את המינימום שוב,

532
00:27:31,830 --> 00:27:32,100
נכון?

533
00:27:32,100 --> 00:27:34,975
ואתה הולך לשמור חוזר
זה, כי הלולאות רק הולך

534
00:27:34,975 --> 00:27:36,010
להמשיך לרוץ, נכון?

535
00:27:36,010 --> 00:27:39,190
>> אז כפי שאתם יכולים לראות, אנחנו
רק צריך פסאודו קוד כללי

536
00:27:39,190 --> 00:27:41,480
של איך אנחנו רוצים תכנית זו כדי להסתכל.

537
00:27:41,480 --> 00:27:46,646
לחזר זה כאן, מה לעשות אנחנו
בדרך כלל צריך לכתוב בקוד שלנו

538
00:27:46,646 --> 00:27:49,270
אם אנחנו רוצים לחזר דרך
מערך, איזה סוג של מבנה?

539
00:27:49,270 --> 00:27:51,030
אני חושב שקריסטבל
כבר אמר את זה קודם.

540
00:27:51,030 --> 00:27:51,500
>> קהל: ללולאה.

541
00:27:51,500 --> 00:27:52,160
>> ANDI פנג: ללולאה?

542
00:27:52,160 --> 00:27:52,770
בדיוק.

543
00:27:52,770 --> 00:27:56,060
אז זה כנראה
הולך להיות ללולאה.

544
00:27:56,060 --> 00:27:59,240
מה היא בדיקה כאן הולכת לרמוז?

545
00:27:59,240 --> 00:28:02,536
בדרך כלל, אם אתה רוצה לבדוק
אם משהו הוא משהו else--

546
00:28:02,536 --> 00:28:03,270
>> קהל: אם.

547
00:28:03,270 --> 00:28:06,790
>> ANDI פנג: אם, נכון?

548
00:28:06,790 --> 00:28:10,790
ולאחר מכן ההחלפה כאן, אנחנו
לעבור על כך, כי דוד

549
00:28:10,790 --> 00:28:12,770
עבר כי בהרצאה גם כן.

550
00:28:12,770 --> 00:28:14,580
ואז לחזר השני implies--

551
00:28:14,580 --> 00:28:15,120
>> קהל: נוסף ללולאה.

552
00:28:15,120 --> 00:28:16,745
>> ANDI פנג: --another ללולאה, בדיוק.

553
00:28:16,745 --> 00:28:19,870

554
00:28:19,870 --> 00:28:22,000
אז אם אנחנו מחפשים
בשלב זה בצורה נכונה, אנחנו

555
00:28:22,000 --> 00:28:24,680
ניתן לראות שאנחנו כנראה
הולך צריך מקונן ללולאה

556
00:28:24,680 --> 00:28:28,330
עם הצהרה מותנית שם
ולאחר מכן פיסת הקוד בפועל זה

557
00:28:28,330 --> 00:28:31,360
הולך להחליף את הערכים.

558
00:28:31,360 --> 00:28:35,980
אז רק בדרך כלל שכתבתי
קוד פסאודו קוד כאן.

559
00:28:35,980 --> 00:28:38,910
ואז אנחנו בעצם הולכים
לפיזי, כתובענה,

560
00:28:38,910 --> 00:28:40,700
תנסה ליישם את זה היום.

561
00:28:40,700 --> 00:28:42,486
בואו נחזור לIDE זה.

562
00:28:42,486 --> 00:28:49,243

563
00:28:49,243 --> 00:28:50,230
>> או הו.

564
00:28:50,230 --> 00:28:51,754
למה זה not-- שם זה.

565
00:28:51,754 --> 00:28:52,253
אוקיי.

566
00:28:52,253 --> 00:28:55,834

567
00:28:55,834 --> 00:28:57,500
מצטער, תן לי לנסות להתקרב קצת יותר.

568
00:28:57,500 --> 00:28:59,310
הנה.

569
00:28:59,310 --> 00:29:05,060
כל מה שאני עושה כאן הוא יצרתי
תכנית בשם "בחירה / sort.c."

570
00:29:05,060 --> 00:29:10,860
יצרתי מערך של תשע
ערכים, 4, 8, 2, 1, 6, 9, 7, 5, 3.

571
00:29:10,860 --> 00:29:14,370
נכון לעכשיו, כפי שאתה יכול
רואה, הם לא מסודרות.

572
00:29:14,370 --> 00:29:17,880
n הולך להיות המספר ש
אומר לך את הסכום של ערכים

573
00:29:17,880 --> 00:29:18,920
יש לך במערך שלך.

574
00:29:18,920 --> 00:29:20,670
במקרה זה, יש לנו תשעה ערכים.

575
00:29:20,670 --> 00:29:23,760
ואני פשוט חייבת ללולאה כאן
שמדפיס את המערך לא ממוינים.

576
00:29:23,760 --> 00:29:28,370
>> ובסופו של הדבר, אני כבר קיבלתי גם ל
לולאה שרק מדפיסה את זה שוב.

577
00:29:28,370 --> 00:29:32,070
אז באופן תיאורטי, אם תכנית זו
הוא עובד בצורה נכונה, בסופו של הדבר,

578
00:29:32,070 --> 00:29:35,670
אתה צריך לראות מודפס ללולאה
שבו 1, 2, 3, 4, 5, 6, 7, 8,

579
00:29:35,670 --> 00:29:39,310
9 כל צורה נכונה כדי.

580
00:29:39,310 --> 00:29:43,410
>> אז יש לנו פסאודו הקוד שלנו כאן.

581
00:29:43,410 --> 00:29:46,090
האם מישהו רוצה צריכה-- אני רק
הולכים לבקש volunteers--

582
00:29:46,090 --> 00:29:49,540
תגיד לי בדיוק מה להקליד אם
אנחנו רוצים, ראשון, פשוט לחזר

583
00:29:49,540 --> 00:29:52,840
עד תחילת מערך זה?

584
00:29:52,840 --> 00:29:55,204
מה שורת קוד אני
כנראה הולך צריך כאן?

585
00:29:55,204 --> 00:29:56,990
>> קהל: [לא ברור]

586
00:29:56,990 --> 00:29:59,010
>> ANDI פנג: כן, מרגיש
מצטער צריכה-- חופשי,

587
00:29:59,010 --> 00:30:02,318
לא צריך לעמוד תחושת up--
חופשי להרים את הקול שלך קצת.

588
00:30:02,318 --> 00:30:08,190
>> קהל: לשווה אני int 0--

589
00:30:08,190 --> 00:30:10,690
>> ANDI פנג: כן, טוב.

590
00:30:10,690 --> 00:30:15,220
>> קהל: הוא אני פחות מאורך מערך.

591
00:30:15,220 --> 00:30:19,630
>> ANDI פנג: אז לשמור ב
אכפת כאן, כי אנחנו

592
00:30:19,630 --> 00:30:23,060
אין לי פונקציה ש
אומר לנו את אורכו של מערך,

593
00:30:23,060 --> 00:30:25,790
כבר יש לנו
ערך שחנויות ש.

594
00:30:25,790 --> 00:30:27,920
נכון?

595
00:30:27,920 --> 00:30:31,010
דבר נוסף שכדאי
בmind-- במערך

596
00:30:31,010 --> 00:30:33,940
תשעה ערכים, מה הם המדדים?

597
00:30:33,940 --> 00:30:38,720
בואו נגיד מערך זה היה 0-3.

598
00:30:38,720 --> 00:30:41,500
אתה רואה שעברת
מדד הוא למעשה 3.

599
00:30:41,500 --> 00:30:45,530
זה לא 4, למרות שיש
ארבעה ערכים במערך.

600
00:30:45,530 --> 00:30:49,866
>> אז כאן, אנחנו צריכים להיות מאוד זהירים
של מה המצב שלנו לכל האורך

601
00:30:49,866 --> 00:30:50,490
זה הולך להיות.

602
00:30:50,490 --> 00:30:51,948
>> קהל: האם לא יהיה זה n מינוס 1?

603
00:30:51,948 --> 00:30:54,440
ANDI פנג: זה הולך
n מינוס 1, בדיוק.

604
00:30:54,440 --> 00:30:57,379
האם זה הגיוני, למה
זה n מינוס 1, כולם?

605
00:30:57,379 --> 00:30:58,920
זה בגלל שמערכים הם אפס צמוד.

606
00:30:58,920 --> 00:31:02,010
הם מתחילים ב 0 ולהפעיל עד n מינוס 1.

607
00:31:02,010 --> 00:31:03,210
כן, זה קצת מסובך.

608
00:31:03,210 --> 00:31:03,730
אוקיי.

609
00:31:03,730 --> 00:31:05,929
ואז--

610
00:31:05,929 --> 00:31:08,054
קהל: Isnt'1 ש
כבר טפל באף,

611
00:31:08,054 --> 00:31:11,400
רק על ידי לא אומר "פחות או
שווה "ורק אומר" פחות מ? "

612
00:31:11,400 --> 00:31:13,108
>> ANDI פנג: זה
שאלה ממש טובה.

613
00:31:13,108 --> 00:31:13,630
אז כן.

614
00:31:13,630 --> 00:31:17,410
אבל גם, בדרך שאנחנו
יישום תקין הבדיקה,

615
00:31:17,410 --> 00:31:19,120
אתה צריך להשוות בין שני ערכים.

616
00:31:19,120 --> 00:31:21,009
אז אתה בעצם רוצה
לעזוב את "ל" ריק.

617
00:31:21,009 --> 00:31:23,050
כי אם אתה משווה
זה אחד, אתה לא הולך

618
00:31:23,050 --> 00:31:25,530
יש משהו אחרי זה
כדי להשוות ל, נכון?

619
00:31:25,530 --> 00:31:27,460
כן.

620
00:31:27,460 --> 00:31:29,297
אז אני ++.

621
00:31:29,297 --> 00:31:30,380
בואו להוסיף בסוגריים שלנו ב.

622
00:31:30,380 --> 00:31:30,880
אופס.

623
00:31:30,880 --> 00:31:33,950

624
00:31:33,950 --> 00:31:34,710
גדול.

625
00:31:34,710 --> 00:31:39,117
אז יש לנו ההתחלה
של הלולאה החיצונית שלנו.

626
00:31:39,117 --> 00:31:41,450
אז עכשיו אנחנו כנראה רוצים
ליצור משתנים לשמירה

627
00:31:41,450 --> 00:31:43,085
מסלול של הערך הקטן ביותר, נכון?

628
00:31:43,085 --> 00:31:45,751
האם מישהו רוצה לתת לי
שורת קוד שהייתי עושה את זה?

629
00:31:45,751 --> 00:31:48,700

630
00:31:48,700 --> 00:31:53,570
מה אנחנו צריכים, אם אנחנו הולכים
לרוצה לאחסן משהו?

631
00:31:53,570 --> 00:31:55,047
>> תקין.

632
00:31:55,047 --> 00:31:57,630
אולי שם טוב יותר של
היה להיות-- "זמני" works-- לחלוטין

633
00:31:57,630 --> 00:32:00,655
אולי בשם יותר בצדק יהיה,
אם אנחנו רוצים value-- הקטן ביותר

634
00:32:00,655 --> 00:32:01,624
>> קהל: מינימום.

635
00:32:01,624 --> 00:32:02,790
ANDI פנג: דקות, יש לנו ללכת.

636
00:32:02,790 --> 00:32:05,230
דקות תהיה טובות.

637
00:32:05,230 --> 00:32:08,340
וכך כאן, מה לעשות אנחנו
רוצה לאתחל אותו ל?

638
00:32:08,340 --> 00:32:09,620
זה קצת מסובך.

639
00:32:09,620 --> 00:32:13,580
כי עכשיו ב
החל ממערך זה,

640
00:32:13,580 --> 00:32:15,730
אתה לא הסתכל על שום דבר, נכון?

641
00:32:15,730 --> 00:32:19,200
אז מה, באופן אוטומטי, אם
אנחנו רק באני שווה 0,

642
00:32:19,200 --> 00:32:22,302
מה שאנחנו רוצים לאתחל
הערך הראשון שלנו למינימום?

643
00:32:22,302 --> 00:32:22,802
קהל: אני.

644
00:32:22,802 --> 00:32:24,790
ANDI פנג: אני, בדיוק.

645
00:32:24,790 --> 00:32:27,040
קריסטבל, למה אנחנו רוצים
כדי לאתחל אותו כדי שאני?

646
00:32:27,040 --> 00:32:28,510
>> קהל: כי, גם,
אנחנו מתחילים עם 0.

647
00:32:28,510 --> 00:32:31,660
אז בגלל שיש לנו מה להשוות
זה ל, המינימום יהיה בסופו של דבר להיות 0.

648
00:32:31,660 --> 00:32:32,451
>> ANDI פנג: בדיוק.

649
00:32:32,451 --> 00:32:34,400
אז היא בדיוק נכונה.

650
00:32:34,400 --> 00:32:36,780
כי יש לנו לא ממש
הסתכל על שום דבר עדיין,

651
00:32:36,780 --> 00:32:38,680
אנחנו לא יודעים מה הוא הערך המינימאלי שלנו.

652
00:32:38,680 --> 00:32:41,960
אנחנו רוצים רק כדי לאתחל אותו ל
אני, ש, כרגע, הוא כאן.

653
00:32:41,960 --> 00:32:44,750
וככל שאנו ממשיכים
להעביר את המערך הזה,

654
00:32:44,750 --> 00:32:48,122
אנחנו תראו את זה, עם כל
לעבור נוסף, אני מגדיל.

655
00:32:48,122 --> 00:32:49,830
ולכן בשלב זה,
אני כנראה הולך

656
00:32:49,830 --> 00:32:52,329
לרוצה להיות מינימאלי,
כי זה הולך להיות כל מה ש

657
00:32:52,329 --> 00:32:54,520
תחילתו של המערך לא ממוינים.

658
00:32:54,520 --> 00:32:55,270
מגניב.

659
00:32:55,270 --> 00:32:58,720
>> אז עכשיו אנחנו רוצים להוסיף
ללולאה כאן זה

660
00:32:58,720 --> 00:33:03,225
הולך לחזר דרך
לא ממוינת, או שאר מערך זה.

661
00:33:03,225 --> 00:33:05,808
האם מישהו רוצה לתת לי
שורת קוד שהייתי עושה את זה?

662
00:33:05,808 --> 00:33:08,870

663
00:33:08,870 --> 00:33:11,330
Hint-- מה שאנחנו צריכים לעשות כאן?

664
00:33:11,330 --> 00:33:17,320

665
00:33:17,320 --> 00:33:18,820
מה הולך בזה ללולאה?

666
00:33:18,820 --> 00:33:19,465
כן.

667
00:33:19,465 --> 00:33:21,590
קהל: אז היינו רוצה
יש מספר שלם שונה,

668
00:33:21,590 --> 00:33:25,080
כי אנחנו פועלים דרך שאר
של המערך במקום i, אז אולי

669
00:33:25,080 --> 00:33:25,760
י.

670
00:33:25,760 --> 00:33:27,301
>> ANDI פנג: כן, j נשמע לי טוב.

671
00:33:27,301 --> 00:33:27,850
שווים?

672
00:33:27,850 --> 00:33:33,930
>> קהל: אז יהיה אני בתוספת 1, כי
אתה מתחיל בערך הבא.

673
00:33:33,930 --> 00:33:40,395
ולאחר מכן לend-- כך שוב, j הוא
פחות מ n מינוס 1, ולאחר מכן j ++.

674
00:33:40,395 --> 00:33:41,103
ANDI פנג: נהדר.

675
00:33:41,103 --> 00:33:48,510

676
00:33:48,510 --> 00:33:52,750
>> ולאחר מכן בכאן, אנחנו הולכים רוצים
כדי לבדוק כדי לראות אם המצב שלנו נפגש,

677
00:33:52,750 --> 00:33:53,250
נכון?

678
00:33:53,250 --> 00:33:55,740
בגלל שאתה רוצה
לשנות את הערך המינימאלי

679
00:33:55,740 --> 00:33:58,700
אם זה קטן יותר ממה שבאמת
אתה משווה את זה, נכון?

680
00:33:58,700 --> 00:34:01,146
אז מה אנחנו הולכים רוצים כאן?

681
00:34:01,146 --> 00:34:04,160

682
00:34:04,160 --> 00:34:04,897
בדוק.

683
00:34:04,897 --> 00:34:06,730
איזה סוג של הצהרה
אנחנו כנראה הולכים

684
00:34:06,730 --> 00:34:08,389
TI רוצה להשתמש אם
רוצה לבדוק משהו?

685
00:34:08,389 --> 00:34:09,360
>> קהל: אם הצהרה.

686
00:34:09,360 --> 00:34:10,485
>> ANDI פנג: אם הצהרה.

687
00:34:10,485 --> 00:34:13,155
אז if-- ומה הולך להיות
המצב שאנחנו רוצים בתוך

688
00:34:13,155 --> 00:34:13,988
אם ההצהרה שלנו?

689
00:34:13,988 --> 00:34:18,255

690
00:34:18,255 --> 00:34:22,960
>> קהל: אם הערך של j
הוא פחות מהערך של אני-

691
00:34:22,960 --> 00:34:24,600
>> ANDI פנג: בדיוק.

692
00:34:24,600 --> 00:34:27,480
אז if-- כך מערך זה נקרא "מערך".

693
00:34:27,480 --> 00:34:27,980
גדול.

694
00:34:27,980 --> 00:34:30,465
אז אם array-- מה זה היה?

695
00:34:30,465 --> 00:34:31,090
תגיד את זה שוב.

696
00:34:31,090 --> 00:34:39,590
>> קהל: אם המערך-J הוא פחות מ
מערך-i, אז היינו לשנות את דקות.

697
00:34:39,590 --> 00:34:41,590
אז דקות תהיה j.

698
00:34:41,590 --> 00:34:44,590

699
00:34:44,590 --> 00:34:47,249
>> ANDI פנג: האם זה הגיוני?

700
00:34:47,249 --> 00:34:48,670
אוקיי.

701
00:34:48,670 --> 00:34:52,929
ועכשיו כאן למטה, אנחנו בעצם
רוצה ליישם את ההחלפה, נכון?

702
00:34:52,929 --> 00:34:58,285
אז זוכר, בהרצאה, שדוד, כאשר
הוא מנסה להחליף כל-- מה היה

703
00:34:58,285 --> 00:34:59,996
מיץ תפוזים it-- וmilk--

704
00:34:59,996 --> 00:35:01,150
>> קהל: זה היה ברוטו.

705
00:35:01,150 --> 00:35:02,816
>> ANDI פנג: כן, זה היה סוג של ברוטו.

706
00:35:02,816 --> 00:35:05,310
אבל זה היה די טוב
מושג מפגין זמן.

707
00:35:05,310 --> 00:35:08,430
אז לחשוב על הערכים שלך כאן.

708
00:35:08,430 --> 00:35:10,794
יש לך מערך
של דקות, מערך שלי,

709
00:35:10,794 --> 00:35:12,460
או מה שאנחנו מנסים להחליף כאן.

710
00:35:12,460 --> 00:35:15,310
ואתה כנראה לא יכול לשפוך אותם ל
אחד את השני באותו הזמן, נכון?

711
00:35:15,310 --> 00:35:17,180
אז מה אנחנו הולכים
לצריך ליצור כאן

712
00:35:17,180 --> 00:35:19,126
כדי להחליף את הערכים בצורה נכונה?

713
00:35:19,126 --> 00:35:19,820
>> קהל: משתנה זמני.

714
00:35:19,820 --> 00:35:21,370
>> ANDI פנג: משתנה זמני.

715
00:35:21,370 --> 00:35:22,570
אז בואו לעשות זמני int.

716
00:35:22,570 --> 00:35:25,681
ראה, זה יהיה טוב יותר
זמן צריכה-- וואו, מה זה היה?

717
00:35:25,681 --> 00:35:26,180
אוקיי.

718
00:35:26,180 --> 00:35:29,800
אז זה היה טוב יותר
זמן לנקוב בשם "זמני". משתנה

719
00:35:29,800 --> 00:35:30,730
אז בואו לעשות זמני int.

720
00:35:30,730 --> 00:35:32,563
מה אנחנו הולכים
להגדיר זמני שווה לכאן?

721
00:35:32,563 --> 00:35:34,752

722
00:35:34,752 --> 00:35:35,335
קהל: מינימום?

723
00:35:35,335 --> 00:35:38,508

724
00:35:38,508 --> 00:35:39,716
ANDI פנג: זה קצת מסובך.

725
00:35:39,716 --> 00:35:43,110

726
00:35:43,110 --> 00:35:44,880
זה באמת לא משנה בסופו של הדבר.

727
00:35:44,880 --> 00:35:47,690
זה לא משנה מה
כדי שתבחר להחליף ב

728
00:35:47,690 --> 00:35:50,862
כל עוד אתה עושה בטוח שאתה
שמירה על המסלול של מה שאתה מחליף.

729
00:35:50,862 --> 00:35:52,250
>> קהל: זה יכול להיות מערך-i.

730
00:35:52,250 --> 00:35:53,666
>> ANDI פנג: כן, בוא לעשות מערך-i.

731
00:35:53,666 --> 00:35:55,950

732
00:35:55,950 --> 00:35:59,305
ואז מה השורה הבאה
של קוד אנחנו רוצים להיות כאן?

733
00:35:59,305 --> 00:36:00,680
קהל: מערך-i שווה מערך-J.

734
00:36:00,680 --> 00:36:07,154

735
00:36:07,154 --> 00:36:08,070
ANDI פנג: ולבסוף?

736
00:36:08,070 --> 00:36:12,070
קהל: מערך-j שווה מערך-i.

737
00:36:12,070 --> 00:36:14,525
שווה או המערך-י: קהל
מערך-temp-- או, זמני.

738
00:36:14,525 --> 00:36:17,135

739
00:36:17,135 --> 00:36:19,430
>> ANDI פנג: אישור.

740
00:36:19,430 --> 00:36:21,510
אז בואו נריץ את זה ותראה את
אם זה הולך לעבוד.

741
00:36:21,510 --> 00:36:37,520

742
00:36:37,520 --> 00:36:39,335
איפה זה קורה?

743
00:36:39,335 --> 00:36:40,210
אה, זו בעיה.

744
00:36:40,210 --> 00:36:44,320
ראה, בקו 40, שאנחנו
מנסה להשתמש במערך-J?

745
00:36:44,320 --> 00:36:47,022
אבל איפה j קיים רק ב?

746
00:36:47,022 --> 00:36:48,402
>> קהל: ללולאה.

747
00:36:48,402 --> 00:36:49,110
ANDI פנג: ימין.

748
00:36:49,110 --> 00:36:51,730
אז מה אנחנו הולכים צריכים לעשות?

749
00:36:51,730 --> 00:36:53,170
>> קהל: הגדר אותו מחוץ כל--

750
00:36:53,170 --> 00:36:57,777

751
00:36:57,777 --> 00:37:00,610
קהל: כן, אני מניח שיש לך
להשתמש אחר אם הצהרה, נכון?

752
00:37:00,610 --> 00:37:05,230
אז כמו, אם minimum--
בסדר, תן לי לחשוב.

753
00:37:05,230 --> 00:37:08,170

754
00:37:08,170 --> 00:37:09,990
>> ANDI פנג: חבר'ה, לנסות
לקחת בואו תסתכלו

755
00:37:09,990 --> 00:37:11,270
ראו, מה משהו שאנחנו יכולים לעשות כאן?

756
00:37:11,270 --> 00:37:11,811
>> קהל: אישור.

757
00:37:11,811 --> 00:37:15,900
אז אם המינימום לא שווה
j-- כך שאם המינימום הוא עדיין אני-

758
00:37:15,900 --> 00:37:17,570
אז אנחנו לא נצטרך להחליף.

759
00:37:17,570 --> 00:37:22,450

760
00:37:22,450 --> 00:37:24,712
>> ANDI פנג: האם זה שווה לי?

761
00:37:24,712 --> 00:37:25,920
מה אתה רוצה לומר כאן?

762
00:37:25,920 --> 00:37:30,494
>> קהל: או כן, אם
המינימום עושה אני לא שווה, כן.

763
00:37:30,494 --> 00:37:39,627

764
00:37:39,627 --> 00:37:40,210
ANDI פנג: אישור.

765
00:37:40,210 --> 00:37:42,040
ובכן זה פותר, סוג של, הבעיות שלנו.

766
00:37:42,040 --> 00:37:47,265
אבל זה עדיין לא פותר
בעיה של מה קורה אם j-- מאז j

767
00:37:47,265 --> 00:37:49,890
לא קיימת מחוצה לו, מה
אתה אנחנו רוצים לעשות עם זה?

768
00:37:49,890 --> 00:37:50,698
להכריז עליו בחוץ?

769
00:37:50,698 --> 00:37:59,410

770
00:37:59,410 --> 00:38:02,730
בואו ננסה לרוץ זה.

771
00:38:02,730 --> 00:38:04,435
או הו.

772
00:38:04,435 --> 00:38:06,200
הסוג שלנו לא עובד.

773
00:38:06,200 --> 00:38:10,060
>> כפי שניתן לראות, ראשוני שלנו
היה לי מערך ערכים אלה.

774
00:38:10,060 --> 00:38:14,800
ואחר כך זה צריך להיות
היה ב1, 2, 3, 4, 5, 6, 7, 8, 9.

775
00:38:14,800 --> 00:38:15,530
זה לא עובד.

776
00:38:15,530 --> 00:38:16,030
אהה.

777
00:38:16,030 --> 00:38:17,184
מה אנחנו עושים?

778
00:38:17,184 --> 00:38:17,850
קהל: Debug.

779
00:38:17,850 --> 00:38:21,787

780
00:38:21,787 --> 00:38:23,370
ANDI פנג: בסדר, אנחנו יכולים לנסות את זה.

781
00:38:23,370 --> 00:38:25,030
אנחנו יכולים לאתר באגים.

782
00:38:25,030 --> 00:38:26,042
להקטין את התצוגה קצת.

783
00:38:26,042 --> 00:38:31,177

784
00:38:31,177 --> 00:38:33,656
בואו להגדיר נקודת העצירה שלנו.

785
00:38:33,656 --> 00:38:37,280
בואו נלך על אישור like--.

786
00:38:37,280 --> 00:38:40,444
>> אז בגלל שאנחנו כבר יודעים ש
שורות אלה, 15 עד 22,

787
00:38:40,444 --> 00:38:43,610
הם working-- כי כל מה שאני עושה הוא
רק iterating דרך וprinting--

788
00:38:43,610 --> 00:38:45,406
אני יכול ללכת קדימה ולדלג על זה.

789
00:38:45,406 --> 00:38:47,280
בואו נתחיל בקו 25.

790
00:38:47,280 --> 00:38:48,712
OOP, תן לי להיפטר מזה.

791
00:38:48,712 --> 00:38:51,598

792
00:38:51,598 --> 00:38:54,057
>> קהל: אז של נקודת העצירה
שבו באגים מתחיל?

793
00:38:54,057 --> 00:38:54,890
ANDI פנג: או מפסיק.

794
00:38:54,890 --> 00:38:55,670
קהל: או מפסיק.

795
00:38:55,670 --> 00:38:55,930
ANDI פנג: כן.

796
00:38:55,930 --> 00:38:58,640
אתה יכול להגדיר נקודות עצירה מרובות ו
זה פשוט יכול לקפוץ מאחת לשנייה.

797
00:38:58,640 --> 00:39:01,590
אבל במקרה הזה אנחנו לא יודעים
שבו השגיאה שקורה.

798
00:39:01,590 --> 00:39:03,780
אז אנחנו פשוט רוצים
להתחיל מלמעלה למטה.

799
00:39:03,780 --> 00:39:05,020
כן.

800
00:39:05,020 --> 00:39:05,550
אוקיי.

801
00:39:05,550 --> 00:39:08,460
>> אז הקו הזה כאן, אנו יכולים להתערב.

802
00:39:08,460 --> 00:39:11,499
אתה יכול לראות כאן למטה,
יש לנו מערך.

803
00:39:11,499 --> 00:39:13,290
אלה הם הערכים
שנמצאים במערך.

804
00:39:13,290 --> 00:39:16,360
האם אתה רואה את זה, איך מדד 0, זה
מתאים לvalue-- הו,

805
00:39:16,360 --> 00:39:17,526
אני הולך לנסות להתקרב.

806
00:39:17,526 --> 00:39:20,650
מצטער, זה ממש קשה
לsee-- במדד מערך 0,

807
00:39:20,650 --> 00:39:24,090
יש לנו ערך של 4 ו
אז כן הלאה וכן הלאה.

808
00:39:24,090 --> 00:39:25,670
יש לנו המשתנים המקומיים שלנו.

809
00:39:25,670 --> 00:39:28,570
עכשיו הוא אני שווה
0, שבו אנו רוצים שזה יהיה.

810
00:39:28,570 --> 00:39:31,540

811
00:39:31,540 --> 00:39:33,690
>> ואז בואו לשמור דריכה דרך.

812
00:39:33,690 --> 00:39:36,850
המינימום שלנו הוא שווה 0,
שאנחנו גם רוצים שזה יהיה.

813
00:39:36,850 --> 00:39:39,470

814
00:39:39,470 --> 00:39:45,560
ואז אנחנו נכנסים השני שלנו ל
לולאה, אם המערך-J הוא פחות מהמערך-i,

815
00:39:45,560 --> 00:39:46,380
שזה לא היה.

816
00:39:46,380 --> 00:39:48,130
אז ראית איך
שדלג על זה?

817
00:39:48,130 --> 00:39:52,430
>> קהל: אז צריך אם
, כל לראות-- לא צריך שמינימום

818
00:39:52,430 --> 00:39:55,424
להיות בתוך הראשון ללולאה?

819
00:39:55,424 --> 00:39:57,340
ANDI פנג: לא, כי
אתה עדיין רוצה לבדוק.

820
00:39:57,340 --> 00:40:00,329
אתה רוצה לעשות השוואה בכל
זמן, גם לאחר שאתה מפעיל דרכו.

821
00:40:00,329 --> 00:40:02,620
אתה פשוט לא רוצה לעשות את זה
על התמסורת הראשונה.

822
00:40:02,620 --> 00:40:05,240
אתה רוצה לעשות את זה עם
כל מעבר נוסף שוב.

823
00:40:05,240 --> 00:40:07,198
אז אתה רוצה לבדוק
המצב שלך בפנים.

824
00:40:07,198 --> 00:40:11,610

825
00:40:11,610 --> 00:40:13,746
אז אנחנו פשוט הולכים ל
להמשיך לרוץ דרך כאן.

826
00:40:13,746 --> 00:40:17,337

827
00:40:17,337 --> 00:40:18,420
אני אתן לכם רמז.

828
00:40:18,420 --> 00:40:23,910
זה קשור לעובדה שכאשר
אתה בודק מותנה שלך,

829
00:40:23,910 --> 00:40:26,600
אתה לא בודק
למדד הנכון.

830
00:40:26,600 --> 00:40:32,510
אז עכשיו אתה בודק ל
מדד מערך של j הוא פחות ממערך

831
00:40:32,510 --> 00:40:33,970
מדד שלי.

832
00:40:33,970 --> 00:40:36,580
אבל מה שאתה עושה עד ב
תחילת ללולאה?

833
00:40:36,580 --> 00:40:38,260
אתה לא הגדרת j שווה לי?

834
00:40:38,260 --> 00:40:41,260

835
00:40:41,260 --> 00:40:45,415
>> כן, אז אנחנו באמת יכולים
לצאת מהבאגים כאן.

836
00:40:45,415 --> 00:40:47,040
אז בואו נסתכל על פסאודו הקוד שלנו.

837
00:40:47,040 --> 00:40:50,070

838
00:40:50,070 --> 00:40:52,580
For-- אנחנו הולכים
מתחיל ב i שווה 0.

839
00:40:52,580 --> 00:40:54,760
אנחנו הולכים ללכת עד n מינוס 1.

840
00:40:54,760 --> 00:40:58,040
בואו לבדוק, היה לנו זכות ש?

841
00:40:58,040 --> 00:40:59,580
כן, זה היה נכון.

842
00:40:59,580 --> 00:41:02,080
>> אז בתוך כאן, אנחנו
הולך ליצור ערך מינימאלי

843
00:41:02,080 --> 00:41:03,630
ולהגדיר ששווה לי.

844
00:41:03,630 --> 00:41:04,950
האם אנחנו עושים את זה?

845
00:41:04,950 --> 00:41:06,270
כן, עשה את זה.

846
00:41:06,270 --> 00:41:10,430
עכשיו בפנימי ללולאה שלנו, אנחנו
הולך לעשות j שווה אני לn 1 מינוס.

847
00:41:10,430 --> 00:41:11,950
האם אנחנו עושים את זה?

848
00:41:11,950 --> 00:41:15,540
ואכן, עשינו את זה.

849
00:41:15,540 --> 00:41:19,922
>> אז עם זאת, מה אנחנו משווים כאן?

850
00:41:19,922 --> 00:41:20,925
>> קהל: j בתוספת 1.

851
00:41:20,925 --> 00:41:21,716
ANDI פנג: בדיוק.

852
00:41:21,716 --> 00:41:24,184

853
00:41:24,184 --> 00:41:27,350
ואז אתה הולך לרוצה להגדיר
המינימום שלך שווה לj בתוספת 1 גם כן.

854
00:41:27,350 --> 00:41:31,057

855
00:41:31,057 --> 00:41:32,640
אז הלכתי דרך שממש מהר.

856
00:41:32,640 --> 00:41:36,190
האם אתם מבינים
למה זה בתוספת י 1?

857
00:41:36,190 --> 00:41:36,890
אוקיי.

858
00:41:36,890 --> 00:41:40,700
>> אז במערך שלך, ב
המעבר הראשון שלך דרך,

859
00:41:40,700 --> 00:41:44,850
שלך ללולאה, לint
אני שווה 0, בואו פשוט

860
00:41:44,850 --> 00:41:46,740
מניח שזה לא השתנה עדיין.

861
00:41:46,740 --> 00:41:53,180

862
00:41:53,180 --> 00:41:56,760
יש לנו מערך של, לחלוטין,
רק ארבעה יסודות ממוינים, נכון?

863
00:41:56,760 --> 00:42:00,760
אז אנחנו רוצים לאתחל אני שווה 0.

864
00:42:00,760 --> 00:42:03,650
ואני הולך רק
לרוץ דרך לולאה זה.

865
00:42:03,650 --> 00:42:08,560
וכך, במעבר הראשון, אנחנו הולכים
כדי לאתחל משתנה בשם "דק"

866
00:42:08,560 --> 00:42:11,245
כי גם אני שווה, משום ש
אין לנו ערך מינימאלי.

867
00:42:11,245 --> 00:42:12,870
אז זה כרגע שווה 0, כמו גם.

868
00:42:12,870 --> 00:42:16,182

869
00:42:16,182 --> 00:42:17,640
ואז אנחנו הולכים לעבור.

870
00:42:17,640 --> 00:42:19,270
ואנחנו רוצים לחזר שוב.

871
00:42:19,270 --> 00:42:22,900
עכשיו שאנחנו כבר מצאנו את מה המינימום שלנו
הוא, שאנחנו רוצים לחזר דרך

872
00:42:22,900 --> 00:42:25,190
שוב כדי לראות אם הוא משווה, נכון?

873
00:42:25,190 --> 00:42:40,440
אז j, כאן, הולך
לי שווה, וזה 0.

874
00:42:40,440 --> 00:42:46,320
ואז אם j מערך פלוס אני, ש
הוא אחד זה הבא על, כפחות

875
00:42:46,320 --> 00:42:49,270
ממה המינימום הנוכחי שלך
הערך הוא, שאתה רוצה להחליף.

876
00:42:49,270 --> 00:42:56,850
>> אז בואו נגיד שיש לנו
יש, כמו, 2, 5, 1, 8.

877
00:42:56,850 --> 00:43:01,610
נכון לעכשיו, הוא שאני שווה
0 וי הוא שווה 0.

878
00:43:01,610 --> 00:43:05,210
וזה הערך המינימאלי שלנו.

879
00:43:05,210 --> 00:43:09,950
אם המערך-J בתוספת אני- כך שאם אחד
זה אחרי אחד אנחנו מסתכלים

880
00:43:09,950 --> 00:43:13,450
גדול מזו שלפניה,
זה הולך להיות מינימאלי.

881
00:43:13,450 --> 00:43:18,120
>> אז הנה אנו רואים כי 5
לא פחות מזה.

882
00:43:18,120 --> 00:43:19,730
אז זה הולך לא להיות 5.

883
00:43:19,730 --> 00:43:23,580
אנו רואים כי 1 הוא פחות מ -2, נכון?

884
00:43:23,580 --> 00:43:32,970
אז עכשיו אנחנו יודעים שהמינימום שלנו הוא
הולך להיות ערך המדד ב 0, 1, 2.

885
00:43:32,970 --> 00:43:34,030
כן?

886
00:43:34,030 --> 00:43:39,170
ואז כשאתה מקבל כאן למטה,
אתה יכול להחליף את הערכים הנכונים.

887
00:43:39,170 --> 00:43:42,610
>> לכן, כאשר אתם פשוט יש j
לפני, אתה לא מסתכל על אחד

888
00:43:42,610 --> 00:43:43,260
אחרי זה.

889
00:43:43,260 --> 00:43:44,520
שחיפשת ב
אותו הערך, ש

890
00:43:44,520 --> 00:43:46,290
לכן זה פשוט לא עושה כלום.

891
00:43:46,290 --> 00:43:49,721
האם זה הגיוני לכולם,
למה אנחנו צריכים את זה בתוספת 1 לשם?

892
00:43:49,721 --> 00:43:50,220
אוקיי.

893
00:43:50,220 --> 00:43:53,345
עכשיו בואו פשוט לרוץ דרכו לעשות
בטוח שאר הקוד הוא נכון.

894
00:43:53,345 --> 00:44:04,424

895
00:44:04,424 --> 00:44:05,340
למה זה קורה?

896
00:44:05,340 --> 00:44:14,780

897
00:44:14,780 --> 00:44:16,364
אה, זה דק ממש כאן.

898
00:44:16,364 --> 00:44:17,780
היינו משווים את הערך הלא נכון.

899
00:44:17,780 --> 00:44:24,944

900
00:44:24,944 --> 00:44:25,906
אוי לא.

901
00:44:25,906 --> 00:44:30,720

902
00:44:30,720 --> 00:44:33,482
>> אה, כן, כאן למטה היינו
החלפת הערכים הלא נכונים גם כן.

903
00:44:33,482 --> 00:44:34,940
כי אנחנו מסתכלים עליי וי.

904
00:44:34,940 --> 00:44:36,440
אלה הם אלה שאנו בודקים.

905
00:44:36,440 --> 00:44:39,160
אנחנו בעצם רוצים להחליף
מינימום, המינימום הנוכחי,

906
00:44:39,160 --> 00:44:40,550
עם כל מה שמחוץ לאחד הוא.

907
00:44:40,550 --> 00:44:59,510

908
00:44:59,510 --> 00:45:05,402
וכמו שאתם יכולים לראות למטה
כאן, יש לנו מערך ממוין.

909
00:45:05,402 --> 00:45:07,110
זה פשוט הייתי צריך לעשות עם
העובדה שכאשר

910
00:45:07,110 --> 00:45:09,350
אנחנו בודקים
ערכים שאנחנו משווים,

911
00:45:09,350 --> 00:45:11,226
אנחנו לא מסתכלים על הערכים תקין.

912
00:45:11,226 --> 00:45:13,850
היינו מסתכלים על אותה אחת
כאן, לא באמת להחליף אותו.

913
00:45:13,850 --> 00:45:17,135
אתה צריך להסתכל על אחד הבא
לזה ואז אתה יכול להחליף.

914
00:45:17,135 --> 00:45:19,260
אז זה מה שהיה סוג של
מטריד את הקוד שלנו לפני.

915
00:45:19,260 --> 00:45:22,460
ומה שעשיתי כאן הוא כל מה ש
הבאגים היו יכולים לעשות בשבילך

916
00:45:22,460 --> 00:45:23,810
רק אני עשיתי את זה ב
לוח, כי זה יותר קל

917
00:45:23,810 --> 00:45:26,320
לראות ולא מנסה
כדי להתמקד על הבאגים.

918
00:45:26,320 --> 00:45:29,391
האם זה הגיוני לכולם?

919
00:45:29,391 --> 00:45:29,890
מגניב.

920
00:45:29,890 --> 00:45:34,800

921
00:45:34,800 --> 00:45:35,410
>> בסדר.

922
00:45:35,410 --> 00:45:41,070
אנחנו יכולים לעבור למדברים על
סימון אסימפטוטי, ש

923
00:45:41,070 --> 00:45:44,580
הוא רק דרך מפוארת של אומר
runtimes של כל מיני אלה.

924
00:45:44,580 --> 00:45:47,650
אז אני יודע דוד, בהרצאה,
נגע runtimes.

925
00:45:47,650 --> 00:45:52,124
והוא עבר את כל הנוסחה
כיצד לחשב את זמני הריצה.

926
00:45:52,124 --> 00:45:53,040
אין דאגות על זה.

927
00:45:53,040 --> 00:45:54,660
אם אתה באמת סקרן
על איך זה עובד,

928
00:45:54,660 --> 00:45:55,810
תרגיש חופשי לדבר איתי אחרי הקטע.

929
00:45:55,810 --> 00:45:57,560
אנחנו יכולים ללכת דרך
נוסחות יחד.

930
00:45:57,560 --> 00:46:00,689
אבל יש לכם את כל באמת
יודע הוא שn בריבוע מעל 2

931
00:46:00,689 --> 00:46:01,980
הוא אותו הדבר כמו n בריבוע.

932
00:46:01,980 --> 00:46:04,710
בגלל המספר הגדול ביותר,
המעריך, גדל ביותר.

933
00:46:04,710 --> 00:46:06,590
וכך למטרות שלנו,
כל אכפת לנו

934
00:46:06,590 --> 00:46:09,470
הוא שמספר הענק שגדל.

935
00:46:09,470 --> 00:46:13,340
>> אז מה הוא המקרה הטוב
זמן ריצה של מיון בחירה?

936
00:46:13,340 --> 00:46:15,830
אם אתה הולך להיות
ללחזר ברשימה

937
00:46:15,830 --> 00:46:18,712
ואז לחזר דרך
שאר רשימה ש,

938
00:46:18,712 --> 00:46:20,420
כמה פעמים הם
אתה הולך כנראה,

939
00:46:20,420 --> 00:46:24,612
בcase-- הגרוע ביותר ב
מקרה הטוב ביותר, sorry-- לרוץ דרך?

940
00:46:24,612 --> 00:46:27,070
אולי השאלה טובה יותר היא
לשאול, מה הוא המקרה הגרוע ביותר

941
00:46:27,070 --> 00:46:28,153
זמן ריצה של מיון בחירה.

942
00:46:28,153 --> 00:46:29,366
קהל: n בריבוע.

943
00:46:29,366 --> 00:46:30,740
ANDI פנג: זה n בריבוע, נכון.

944
00:46:30,740 --> 00:46:36,986
אז דרך קלה לחשוב על זה כמו,
כל זמן יש לך שני מקוננים ללולאות,

945
00:46:36,986 --> 00:46:38,110
זה הולך להיות בריבוע n.

946
00:46:38,110 --> 00:46:40,386
כי לא רק אתה
פועל באמצעות שוב,

947
00:46:40,386 --> 00:46:42,260
אתה צריך לחזור
סביב ולהפעיל דרכו

948
00:46:42,260 --> 00:46:44,980
שוב פנימה לכל ערך.

949
00:46:44,980 --> 00:46:48,640
אז במקרה כזה, אתה מפעיל n
פעמים n בריבוע, שהוא-- מצטערים,

950
00:46:48,640 --> 00:46:50,505
n פעמים n, אשר שווה n בריבוע.

951
00:46:50,505 --> 00:46:53,230

952
00:46:53,230 --> 00:46:56,360
>> וסוג הוא גם קצת
ייחודי במובן

953
00:46:56,360 --> 00:46:59,774
שזה לא משנה אם אלה
ערכים כבר נמצאים בצו.

954
00:46:59,774 --> 00:47:01,440
זה עדיין הולך לרוץ דרך בכל מקרה.

955
00:47:01,440 --> 00:47:03,872
בואו נגיד שזה היה 1, 2, 3, 4.

956
00:47:03,872 --> 00:47:07,080
לא משנה אם או לא זה היה ב
כדי, זה עדיין היה רץ ב

957
00:47:07,080 --> 00:47:08,620
ועדיין בדק את הערך המינימאלי.

958
00:47:08,620 --> 00:47:10,100
זה היה יכול להיות
אותו מספר של בדיקות

959
00:47:10,100 --> 00:47:12,780
בכל פעם, גם אם זה
לא ממש לגעת בשום דבר.

960
00:47:12,780 --> 00:47:16,940
>> אז במקרה כזה, את הטוב ביותר והגרוע ביותר
runtimes הן למעשה שווה ערך.

961
00:47:16,940 --> 00:47:19,160
אז הריצה הצפויה
מסוג הבחירה,

962
00:47:19,160 --> 00:47:23,790
שבו אנו מייעדים ידי הסמל
של תטא, תטא, במקרה זה,

963
00:47:23,790 --> 00:47:24,790
היה גם להיות בריבוע n.

964
00:47:24,790 --> 00:47:26,480
כל שלושת אלה יהיו בריבוע n.

965
00:47:26,480 --> 00:47:29,653
האם כולם ברורים במה
זמן הריצה בריבוע n?

966
00:47:29,653 --> 00:47:33,360

967
00:47:33,360 --> 00:47:33,980
>> בסדר.

968
00:47:33,980 --> 00:47:39,120
אז רק אני הולך לרוץ מהר
דרך שאר מיני.

969
00:47:39,120 --> 00:47:41,137
האלגוריתם ל
בועת sort-- לזכור,

970
00:47:41,137 --> 00:47:43,220
זה היה ראשון
דוד ניגש בהרצאה.

971
00:47:43,220 --> 00:47:46,000
בעיקרו של דבר, אותך צעד אחר
דרך כל הרשימה

972
00:47:46,000 --> 00:47:48,950
ואתה swap-- אתה רק
להשוות שניים בכל פעם.

973
00:47:48,950 --> 00:47:51,350
ואם אחד זה יותר,
ממה שאתה פשוט להחליף אותם.

974
00:47:51,350 --> 00:47:53,590
אז אם אלה הם גדולים יותר, היית להחליף.

975
00:47:53,590 --> 00:47:56,180
יש לי רשמי כאן.

976
00:47:56,180 --> 00:47:59,100
>> אז בואו נגיד שיש לך 8, 6, 4, 2.

977
00:47:59,100 --> 00:48:00,571
היית להשוות 8 ו6.

978
00:48:00,571 --> 00:48:01,570
היית צריך להחליף אותם.

979
00:48:01,570 --> 00:48:02,610
היית להשוות 8 ו4.

980
00:48:02,610 --> 00:48:03,609
היית צריך להחליף אותם.

981
00:48:03,609 --> 00:48:07,000
אם אתה צריך להחליף את 8 ו
2, לשנות אותם גם כן.

982
00:48:07,000 --> 00:48:10,760
אז במובן כזה, אתה יכול לראות,
שיחק על פני תקופה ארוכה של זמן,

983
00:48:10,760 --> 00:48:13,730
איך סוג הערכים של בועה ל
קצוות, וזו הסיבה שאנחנו קוראים לזה

984
00:48:13,730 --> 00:48:15,320
מיון בועות.

985
00:48:15,320 --> 00:48:19,950
>> היינו רץ דרך רק שוב ב
לעוברנו השני, ולעבור השלישי שלנו,

986
00:48:19,950 --> 00:48:21,150
ולעבור הרביעי שלנו.

987
00:48:21,150 --> 00:48:25,820
בעיקרו של דבר, בועת סוג רק פועלת
עד שאתה לא עושה יותר עסקות החלף.

988
00:48:25,820 --> 00:48:31,109
אז במובן הזה, זה רק
פסאודו הקוד הכללי לזה.

989
00:48:31,109 --> 00:48:32,650
אין דאגות, אלה יהיו כולם באינטרנט.

990
00:48:32,650 --> 00:48:34,990
אנחנו לא באמת צריכים ללכת על זה.

991
00:48:34,990 --> 00:48:38,134
>> אנחנו פשוט לאתחל דלפק
משתנה שמתחיל ב 0.

992
00:48:38,134 --> 00:48:39,800
ואנחנו איטרציות בכל המערך.

993
00:48:39,800 --> 00:48:43,420
ואם ערך אחד הוא-- אם זה
הערך גדול מהערך ש,

994
00:48:43,420 --> 00:48:44,610
אתה הולך להחליף אותם.

995
00:48:44,610 --> 00:48:46,860
ואז אתה פשוט
הולך להמשיך.

996
00:48:46,860 --> 00:48:47,970
ואתה הולך לספור.

997
00:48:47,970 --> 00:48:50,845
ואתה רק הולך להמשיך לעשות
זה זמן שהדלפק הוא גדול יותר

998
00:48:50,845 --> 00:48:53,345
מ 0, מה שאומר ש
בכל פעם שאתה צריך להחליף,

999
00:48:53,345 --> 00:48:55,220
אתה יודע שאתה רוצה ללכת
חזור ובדוק שוב.

1000
00:48:55,220 --> 00:48:59,510
אתה רוצה לשמור על בדיקה עד שאתה יודע
כי אתה לא צריך להחליף יותר.

1001
00:48:59,510 --> 00:49:05,570
>> אז מה הם הטוב ביותר והגרוע ביותר
מקרה runtimes למיון בועות?

1002
00:49:05,570 --> 00:49:09,300
וhint-- זה שונה בעצם
מסוג הבחירה במובן

1003
00:49:09,300 --> 00:49:11,810
כי שתי תשובות אלה הן לא אותו הדבר.

1004
00:49:11,810 --> 00:49:14,709
תחשוב על מה שיקרה ב
מקרה אם זה היה כבר מסודרים.

1005
00:49:14,709 --> 00:49:16,500
ולחשוב על מה ש
היה קורה אם זה היה

1006
00:49:16,500 --> 00:49:18,372
במקרה שבו לא מסודרים.

1007
00:49:18,372 --> 00:49:20,580
ואתה יכול סוג של לרוץ
דרך למה שקורה.

1008
00:49:20,580 --> 00:49:22,954
אני אתן לכם, כמו, 30
שניות לחשוב על זה.

1009
00:49:22,954 --> 00:49:52,330

1010
00:49:52,330 --> 00:49:53,540
>> אוקיי.

1011
00:49:53,540 --> 00:49:57,462
למישהו יש ניחוש מה
מקרה הגרוע ביותר של זמן הריצה מיון בועות היא?

1012
00:49:57,462 --> 00:49:57,962
כן.

1013
00:49:57,962 --> 00:50:07,810
>> קהל: האם זה יהיה, כמו, n פעמים
n מינוס 1 או משהו כזה?

1014
00:50:07,810 --> 00:50:10,650
כמו, בכל פעם שהוא פועל,
זה פשוט, כמו, החלפה אחד פחות

1015
00:50:10,650 --> 00:50:10,960
כי כל מה שהיה.

1016
00:50:10,960 --> 00:50:12,668
>> ANDI פנג: כן, כל כך
אתה צודק לחלוטין.

1017
00:50:12,668 --> 00:50:15,940
וזה מקרה שבך
התשובה הייתה למעשה מורכבת יותר

1018
00:50:15,940 --> 00:50:17,240
יותר מזה שאנחנו צריכים לתת.

1019
00:50:17,240 --> 00:50:19,772
אז זה הולך run-- אני
הולך למחוק את כל זה כאן.

1020
00:50:19,772 --> 00:50:20,480
האם כולם טוב?

1021
00:50:20,480 --> 00:50:21,869
האם אני יכול למחוק את זה?

1022
00:50:21,869 --> 00:50:22,368
אוקיי.

1023
00:50:22,368 --> 00:50:27,904

1024
00:50:27,904 --> 00:50:30,320
אתה הולך לרוץ דרך n
פעמים בפעם הראשונה, נכון?

1025
00:50:30,320 --> 00:50:33,200
והם הולכים לרוץ דרך
n מינוס 1 בפעם השנייה, נכון?

1026
00:50:33,200 --> 00:50:37,130
ואז אתה הולך לשמור
הולך, n 2, וכולי.

1027
00:50:37,130 --> 00:50:40,210
דוד עשה את זה בהרצאה, שבו,
אם אתה הוסיף את כל הערכים האלה,

1028
00:50:40,210 --> 00:50:48,080
אתה מקבל משהו שהוא like-- yeah--
מעל 2, אשר למעשה רק מפחית

1029
00:50:48,080 --> 00:50:49,784
עד n בריבוע.

1030
00:50:49,784 --> 00:50:51,700
אתה הולך לקבל
חלק מוזר שם.

1031
00:50:51,700 --> 00:50:53,892
וכך רק יודע ש
n בריבוע תמיד

1032
00:50:53,892 --> 00:50:55,350
גובר על כל החלק.

1033
00:50:55,350 --> 00:50:58,450
ולכן במקרה זה, הגרוע ביותר
זמן ריצה יהיה בריבוע n.

1034
00:50:58,450 --> 00:51:00,210
אם זה היה יורד
כדי, חושב, אתה

1035
00:51:00,210 --> 00:51:02,530
צריך לעשות החלפה בכל פעם.

1036
00:51:02,530 --> 00:51:05,170
>> מה יהיו, באופן פוטנציאלי,
זמן הריצה מקרה הטוב?

1037
00:51:05,170 --> 00:51:08,580
בואו נגיד, אם הרשימה הייתה כבר
כדי, מה היית זמן הריצה להיות?

1038
00:51:08,580 --> 00:51:09,565
>> קהל: n.

1039
00:51:09,565 --> 00:51:10,690
ANDI פנג: זה n, בדיוק.

1040
00:51:10,690 --> 00:51:11,600
ולמה זה n?

1041
00:51:11,600 --> 00:51:13,850
קהל: מכיוון שאתה רק
צריך לבדוק בכל פעם.

1042
00:51:13,850 --> 00:51:14,770
ANDI פנג: בדיוק.

1043
00:51:14,770 --> 00:51:17,150
אז בזמן הריצה הטובה ביותר האפשרית,
אם רשימה זו כבר הייתה

1044
00:51:17,150 --> 00:51:20,270
sorted-- נניח 1, 2, 3, 4--
הייתי הולך רק דרך, היית לבדוק,

1045
00:51:20,270 --> 00:51:21,720
היית רואה, אה, כולם יסתדרו.

1046
00:51:21,720 --> 00:51:22,636
אני לא צריך להחליף.

1047
00:51:22,636 --> 00:51:23,370
אני סיימתי.

1048
00:51:23,370 --> 00:51:26,500
אז במקרה כזה, זה פשוט n
או את מספר הצעדים שאתה פשוט

1049
00:51:26,500 --> 00:51:29,870
הייתי צריך לבדוק ברשימה הראשונה.

1050
00:51:29,870 --> 00:51:33,990
>> ואחרי, אנחנו עכשיו פגעו
מיון הכנסה, שבו

1051
00:51:33,990 --> 00:51:39,260
האלגוריתם הוא למעשה לפער
אותו לחלק ממוין ולא ממוין.

1052
00:51:39,260 --> 00:51:42,810
ואז אחד אחד,
הערכים ממוינים הם

1053
00:51:42,810 --> 00:51:46,880
הוכנס המתאים
עמדות בתחילת הרשימה.

1054
00:51:46,880 --> 00:51:52,120
>> כך למשל, יש לנו
רשימה של 3, 5, 2, 6, 4 שוב.

1055
00:51:52,120 --> 00:51:54,750
אנחנו יודעים שזה כרגע
לא ממוינים כי יש לנו רק

1056
00:51:54,750 --> 00:51:57,030
התחיל להסתכל על זה.

1057
00:51:57,030 --> 00:52:00,610
אנחנו נסתכל ואנחנו יודעים ש
הערך הראשון הוא מיון, נכון?

1058
00:52:00,610 --> 00:52:04,190
אם אתה מחפש רק במערך של
גודל אחד, אתה יודע שזה מסודרים.

1059
00:52:04,190 --> 00:52:08,230
>> אז אנחנו יודעים ש
ארבעה אחרים הם לא ממוינים.

1060
00:52:08,230 --> 00:52:10,980
אנחנו עוברים ואנחנו רואים ערך ש.

1061
00:52:10,980 --> 00:52:11,730
בוא נחזור.

1062
00:52:11,730 --> 00:52:13,130
ראה ערך זה של 5?

1063
00:52:13,130 --> 00:52:14,110
אנחנו נסתכל על זה.

1064
00:52:14,110 --> 00:52:15,204
אנו משווים אותו ל -3.

1065
00:52:15,204 --> 00:52:17,870
אנחנו יודעים שזה גדול יותר מ
3, כך שאנחנו יודעים שזה מסודרים.

1066
00:52:17,870 --> 00:52:22,940
אז עכשיו אנחנו יודעים ששני הראשונים
מסודרים והשלוש האחרונים הם לא.

1067
00:52:22,940 --> 00:52:24,270
>> אנחנו נסתכל על 2.

1068
00:52:24,270 --> 00:52:25,720
אנחנו הראשונים לבדוק את זה עם 5.

1069
00:52:25,720 --> 00:52:26,700
האם זה פחות מ 5?

1070
00:52:26,700 --> 00:52:27,240
זה לא.

1071
00:52:27,240 --> 00:52:29,510
אז אנחנו צריכים לשמור מסתכלים למטה.

1072
00:52:29,510 --> 00:52:30,940
אז לך לבדוק את 2 3.

1073
00:52:30,940 --> 00:52:31,850
האם זה פחות מ?

1074
00:52:31,850 --> 00:52:32,350
מס '

1075
00:52:32,350 --> 00:52:35,430
אז אתה יודע 2 יש להיות מוכנס
לחזית ו 3 ו -5

1076
00:52:35,430 --> 00:52:38,200
לשניהם יש להידחף החוצה.

1077
00:52:38,200 --> 00:52:42,190
לעשות את זה שוב עם 6 ו -4.

1078
00:52:42,190 --> 00:52:48,962
ואנחנו רק לשמור על בדיקה במהות,
שבו אנחנו פשוט לבדוק, לבדוק, לבדוק.

1079
00:52:48,962 --> 00:52:51,170
ועד שהוא בימין
עמדה, אנחנו סוג של רק

1080
00:52:51,170 --> 00:52:54,890
הכנס אותו למיקום הנכון,
המקום שבו שמו של זה בא.

1081
00:52:54,890 --> 00:52:59,830
>> אז זה רק האלגוריתם,
פסאודו קוד כשלעצמה, סוג של,

1082
00:52:59,830 --> 00:53:04,990
על איך היינו ליישם
מיון הכנסה.

1083
00:53:04,990 --> 00:53:05,954
פסאודו קוד הוא כאן.

1084
00:53:05,954 --> 00:53:06,620
זה כל האינטרנט.

1085
00:53:06,620 --> 00:53:10,720
אל דאגה, אם אתם נמצאים
מנסה להעתיק את זה למטה.

1086
00:53:10,720 --> 00:53:14,500
אז שוב, אותו question-- מה
תהיה הטוב ביותר והגרועה ביותר runtimes

1087
00:53:14,500 --> 00:53:16,120
למיון הכנסה?

1088
00:53:16,120 --> 00:53:17,750
זה מאוד דומה לשאלה האחרונה.

1089
00:53:17,750 --> 00:53:20,479
אני אתן לכם, כמו, 30
שניות לחשוב על זה גם כן.

1090
00:53:20,479 --> 00:53:47,150

1091
00:53:47,150 --> 00:53:50,071
>> אישור האם מישהו רוצה
תן לי את זמן הריצה הגרועה ביותר?

1092
00:53:50,071 --> 00:53:50,570
כן.

1093
00:53:50,570 --> 00:53:51,490
>> קהל: n בריבוע.

1094
00:53:51,490 --> 00:53:52,573
>> ANDI פנג: זה n בריבוע.

1095
00:53:52,573 --> 00:53:53,730
ולמה זה n בריבוע?

1096
00:53:53,730 --> 00:53:57,562
>> קהל: כי ב
בסדר הפוך, יש לך

1097
00:53:57,562 --> 00:54:02,619
לעבור פעמים n n, אשר הוא--

1098
00:54:02,619 --> 00:54:03,660
ANDI פנג: כן, בדיוק.

1099
00:54:03,660 --> 00:54:06,610
אז אותו דבר כמו במיון הבועות.

1100
00:54:06,610 --> 00:54:08,720
אם רשימה זו היא ב
בסדר יורד, אתה

1101
00:54:08,720 --> 00:54:11,240
תצטרך לבדוק פעם ראשונה.

1102
00:54:11,240 --> 00:54:13,470
ולאחר מכן עם כל
ערך נוסף, אתה

1103
00:54:13,470 --> 00:54:16,390
אצטרך לבדוק את זה נגד
כל ערך, נכון?

1104
00:54:16,390 --> 00:54:20,290
וכך לגמרי, אתה הולך לעשות
פעמים לעבור n n אחר לעבור, ש

1105
00:54:20,290 --> 00:54:21,750
בריבוע n.

1106
00:54:21,750 --> 00:54:22,860
מה לגבי המקרה הטוב?

1107
00:54:22,860 --> 00:54:24,360
כן.

1108
00:54:24,360 --> 00:54:28,840
>> קהל: n מינוס 1, כי
ראשון כבר בריבוע.

1109
00:54:28,840 --> 00:54:30,270
>> ANDI פנג: אז, קרוב.

1110
00:54:30,270 --> 00:54:31,850
התשובה היא בעצם n.

1111
00:54:31,850 --> 00:54:37,189
כי בעוד הראשון הוא
מסודרים, זה לא יכול מעשה-- זה

1112
00:54:37,189 --> 00:54:38,980
רק לנו מזל, ב
דוגמא ש, כי 2

1113
00:54:38,980 --> 00:54:40,930
קרה להיות המספר הקטן ביותר.

1114
00:54:40,930 --> 00:54:43,680
אבל זה לא תמיד המקרה.

1115
00:54:43,680 --> 00:54:48,040
אם 2 כבר מסודרים בתחילת
אבל אתה מסתכל ויש כאן 1,

1116
00:54:48,040 --> 00:54:49,144
1 הולך להקפיץ אותו.

1117
00:54:49,144 --> 00:54:51,060
וזה הולך בסופו של
עד שנתקל בכל מקרה.

1118
00:54:51,060 --> 00:54:56,250
>> אז במקרה הטוב,
זה בעצם רק הולך להיות n.

1119
00:54:56,250 --> 00:54:59,090
אם יש לך 1, 2, 3,
4, 5, 6, 7, 8, אתה

1120
00:54:59,090 --> 00:55:00,940
הולך לרוץ דרך
שכל רשימה אחת

1121
00:55:00,940 --> 00:55:03,430
כדי לבדוק אם הכול בסדר.

1122
00:55:03,430 --> 00:55:07,390
האם כולם ברור בריצה
כמו גם זמנים של בחירה?

1123
00:55:07,390 --> 00:55:09,960
אני יודע שאני עובר
אלה מהירים באמת.

1124
00:55:09,960 --> 00:55:13,330
אבל רק יודע שאם אתה יודע
מושגים כלליים, אתה צריך להיות טוב.

1125
00:55:13,330 --> 00:55:16,070
אוקיי.

1126
00:55:16,070 --> 00:55:19,790
אז רק אני אתן לכם אולי, כמו,
דקות לדבר עם השכנים שלך

1127
00:55:19,790 --> 00:55:21,890
על מה בדיוק כמה
ההבדלים העיקריים

1128
00:55:21,890 --> 00:55:23,540
בין סוגים אלה של מיני.

1129
00:55:23,540 --> 00:56:24,571

1130
00:56:24,571 --> 00:56:25,570
אנחנו נלך על זה בקרוב.

1131
00:56:25,570 --> 00:56:26,444
קהל: אה, בסדר.

1132
00:56:26,444 --> 00:56:27,320
ANDI פנג: כן.

1133
00:56:27,320 --> 00:56:28,380
אוקיי.

1134
00:56:28,380 --> 00:56:33,420
מגניב, בואו לכנס כתובענה.

1135
00:56:33,420 --> 00:56:34,330
אוקיי.

1136
00:56:34,330 --> 00:56:37,579
אז זה היה סוג של
שאלה פתוחה במובן

1137
00:56:37,579 --> 00:56:39,120
כי יש המון תשובות להם.

1138
00:56:39,120 --> 00:56:40,746
ונלך על כמה מהם בקצרה.

1139
00:56:40,746 --> 00:56:43,411
רק רציתי להביא לך חבר '
לחשוב על מה שהבדיל

1140
00:56:43,411 --> 00:56:44,530
כל שלושת הסוגים של מיני.

1141
00:56:44,530 --> 00:56:47,440
ושמעתי, גם, גדול
question-- מה להתמזג לעשות סוג?

1142
00:56:47,440 --> 00:56:50,110
שאלה גדולה, כי זה
מה שאנחנו מכסים הבאים.

1143
00:56:50,110 --> 00:56:52,850
>> אז למזג סוג הוא
סוג שפונקציות אחד

1144
00:56:52,850 --> 00:56:56,100
מאוד שונה מהסוגים האחרים.

1145
00:56:56,100 --> 00:56:58,180
כאתם יכולים see--
לא דוד לעשות הדגמה ש

1146
00:56:58,180 --> 00:57:01,130
שבו הוא היה כל מגניב
רעשים לראות איך למזג

1147
00:57:01,130 --> 00:57:04,010
סוג רץ, כמו, לאין שיעור
מהר יותר משני סוגים האחרים?

1148
00:57:04,010 --> 00:57:04,510
אוקיי.

1149
00:57:04,510 --> 00:57:07,580
אז זה בגלל מיזוג
סוג מיישם פער ש

1150
00:57:07,580 --> 00:57:11,020
ולכבוש מושג שיש לנו
דיבר על הרבה בהרצאה.

1151
00:57:11,020 --> 00:57:14,550
שבמובן זה שאנו רוצים לעבוד
חכם, לא קשה, כאשר אתה מחלק

1152
00:57:14,550 --> 00:57:18,120
ולכבוש בעיות, ולשבור אותם
למטה, ואז לשים אותם יחד,

1153
00:57:18,120 --> 00:57:19,930
דברים טובים תמיד קורים.

1154
00:57:19,930 --> 00:57:21,960
>> לכן הדרך שלמזג
סוג בעצם עובד

1155
00:57:21,960 --> 00:57:24,660
הוא שזה מחלק
מערך ממוין במחצית.

1156
00:57:24,660 --> 00:57:26,500
ואז זה הגיע שני חצאים של מערכים.

1157
00:57:26,500 --> 00:57:28,220
וזה פשוט ממיין שני חצאים אלה.

1158
00:57:28,220 --> 00:57:31,750
זה פשוט ממשיך החלוקה במחצית, ב
מחצית, במחצית עד שהכל מסודרים

1159
00:57:31,750 --> 00:57:33,680
ולאחר מכן באופן רקורסיבי
מכניס את כל זה ביחד.

1160
00:57:33,680 --> 00:57:36,550
>> אז זה באמת מופשט.

1161
00:57:36,550 --> 00:57:38,750
אז זה רק קצת פסאודו קוד.

1162
00:57:38,750 --> 00:57:41,040
האם זה הגיוני ב
הדרך זה פועל?

1163
00:57:41,040 --> 00:57:43,870
אז בואו נגיד שיש לך
מערך של אלמנטי n, נכון?

1164
00:57:43,870 --> 00:57:45,450
אם n הוא פחות מ -2, אתה יכול לחזור.

1165
00:57:45,450 --> 00:57:49,040
כי אתה יודע שאם יש
רק דבר אחד, זה חייב להיות מסודר.

1166
00:57:49,040 --> 00:57:52,600
אחר, אתה למיין את החצי השמאלי,
ואז אתה למיין את המחצית הימנית,

1167
00:57:52,600 --> 00:57:54,140
ואז אתה למזג.

1168
00:57:54,140 --> 00:57:56,979
>> אז בזמן שנראה ממש קל,
במציאות, חושב על זה

1169
00:57:56,979 --> 00:58:00,270
סוג של קשה. בגלל שאתה כמו,
ובכן, זה סוג של ריצה על עצמו.

1170
00:58:00,270 --> 00:58:00,769
נכון?

1171
00:58:00,769 --> 00:58:02,430
זה פועל על עצמו.

1172
00:58:02,430 --> 00:58:05,479
אז במובן הזה, דוד נגע
על רקורסיה בכיתה.

1173
00:58:05,479 --> 00:58:07,270
וזה רעיון
נדבר על יותר.

1174
00:58:07,270 --> 00:58:11,430
זה שזה, שתי שורות אלה
כאן, למעשה היא רק התכנית

1175
00:58:11,430 --> 00:58:13,860
אומר את זה כדי לרוץ עצמו
עם קלט שונה.

1176
00:58:13,860 --> 00:58:17,230
אז במקום לנהל את עצמו עם
מכלול אלמנטי n,

1177
00:58:17,230 --> 00:58:20,530
אתה יכול לשבור אותו לתוך
מחצית השמאלית וחצי תקין

1178
00:58:20,530 --> 00:58:22,680
ולאחר מכן להפעיל אותו שוב.

1179
00:58:22,680 --> 00:58:26,050
>> ואז מסתכלים על זה מבחינה ויזואלית,
כי אני לומד חזותי.

1180
00:58:26,050 --> 00:58:27,270
זה עובד יותר טוב בשבילי.

1181
00:58:27,270 --> 00:58:29,890
אז אנחנו מסתכלים דוגמא חזותית כאן.

1182
00:58:29,890 --> 00:58:36,237
>> נניח שיש לנו מערך, שש
אלמנטים, 3, 5, 2, 6, 4, 1, לא מסודרים.

1183
00:58:36,237 --> 00:58:37,820
בסדר, יש הרבה בדף זה.

1184
00:58:37,820 --> 00:58:43,179
אז אם אתם יכולים להסתכל ב
צעד הראשון כאן, 3, 5, 2, 6, 4, 1,

1185
00:58:43,179 --> 00:58:44,220
אתה יכול לפצל אותו לשתיים.

1186
00:58:44,220 --> 00:58:45,976
יש לך 3, 5, 2, 6, 4, 1.

1187
00:58:45,976 --> 00:58:48,850
אתה יודע כי אלה aren't--
לא יודע אם הם מסודרים או לא,

1188
00:58:48,850 --> 00:58:52,517
כך אוכל לשמור פירוקם, במחצית,
במחצית, במחצית, עד סופו של דבר,

1189
00:58:52,517 --> 00:58:53,600
יש לך רק אלמנט אחד.

1190
00:58:53,600 --> 00:58:56,790
ואלמנט אחד הוא תמיד מסודרים, נכון?

1191
00:58:56,790 --> 00:59:01,560
>> אז אנחנו יודעים ש3, 5, 2, 4, 6,
1, על ידי עצמם, מסודרים.

1192
00:59:01,560 --> 00:59:05,870
ועכשיו אנחנו יכולים להחזיר אותם יחד.

1193
00:59:05,870 --> 00:59:07,510
אז אנחנו יודעים 3, 5.

1194
00:59:07,510 --> 00:59:08,510
אנחנו להרכיב אותם.

1195
00:59:08,510 --> 00:59:09,617
אנחנו יודעים שזה ממוין.

1196
00:59:09,617 --> 00:59:10,450
2 של עדיין שם.

1197
00:59:10,450 --> 00:59:11,830
אנחנו יכולים לשים את 4 ואת 6 ביחד.

1198
00:59:11,830 --> 00:59:13,996
אנחנו יודעים שזה מסודרים,
ולכן אנחנו להרכיב ש.

1199
00:59:13,996 --> 00:59:14,940
ו1 הוא שם.

1200
00:59:14,940 --> 00:59:18,720
>> ואז אתה פשוט מסתכל
שני חצאים אלה ממש כאן.

1201
00:59:18,720 --> 00:59:21,300
יש לך 3, 5, 2, 2, 3, 5.

1202
00:59:21,300 --> 00:59:23,465
אתה פשוט יכול להשוות
מתחיל מכל הדבר.

1203
00:59:23,465 --> 00:59:26,340
כי אתה יודע שזה מסודרים
ואתה יודע שזה מסודרים.

1204
00:59:26,340 --> 00:59:29,360
אז אתה אפילו לא צריך
להשוות 5, אתה פשוט להשוות את 3.

1205
00:59:29,360 --> 00:59:32,070
ו 2 הוא פחות מ -3, כך
אתה יודע 2 חייבים ללכת בסופו של הדבר.

1206
00:59:32,070 --> 00:59:33,120
>> אותו דבר שם.

1207
00:59:33,120 --> 00:59:34,740
1 חייב ללכת כאן.

1208
00:59:34,740 --> 00:59:37,330
ואז כשאתה הולך לשים
אלה שני ערכים יחד,

1209
00:59:37,330 --> 00:59:39,950
אתה יודע שזה מסודרים ו
אתה יודע שמסודר.

1210
00:59:39,950 --> 00:59:43,240
אז ו1
2, 1 הוא פחות מ -2.

1211
00:59:43,240 --> 00:59:45,570
שאומר לך ש1
צריך ללכת על קצה זה

1212
00:59:45,570 --> 00:59:47,480
אפילו בלי להסתכל על 3 או 5.

1213
00:59:47,480 --> 00:59:50,100
ולאחר מכן 4, אתה יכול פשוט
לבדוק, זה הולך ימינה בכאן.

1214
00:59:50,100 --> 00:59:51,480
אתה לא צריך להסתכל על 5.

1215
00:59:51,480 --> 00:59:52,570
אותו דבר עם 6.

1216
00:59:52,570 --> 00:59:55,860
אתה יודע שזה רק 6--
לא צריכה להיות נראה.

1217
00:59:55,860 --> 00:59:57,870
>> וכך, בדרך זו, אתה
רק להציל את עצמך

1218
00:59:57,870 --> 00:59:59,526
הרבה שלבים כאשר אתה משווה.

1219
00:59:59,526 --> 01:00:02,150
אתה לא צריך להשוות את כל
אלמנט נגד גורמים אחרים.

1220
01:00:02,150 --> 01:00:05,230
אתה פשוט להשוות נגד אלה
כי אתה צריך להשוות את זה נגד.

1221
01:00:05,230 --> 01:00:06,870
אז זה סוג של מושג מופשט.

1222
01:00:06,870 --> 01:00:10,540
אל דאגה, אם זה לא
די להכות אותך נכון עדיין.

1223
01:00:10,540 --> 01:00:14,740
אבל בדרך כלל, זה הוא
איך סוג מיזוג עובד.

1224
01:00:14,740 --> 01:00:17,750
שאלות, שאלות מהירות,
לפני שאני ממשיך הלאה?

1225
01:00:17,750 --> 01:00:18,550
כן.

1226
01:00:18,550 --> 01:00:22,230
>> קהל: אז אתה אמר שאתה לוקח
1, ולאחר מכן 4, ו6

1227
01:00:22,230 --> 01:00:23,860
ולשים אותם ב.

1228
01:00:23,860 --> 01:00:26,800
כל כך לא את-- לא
אתה מסתכל עליהם

1229
01:00:26,800 --> 01:00:28,544
כאלמנטים נפרדים, לא כמו כל?

1230
01:00:28,544 --> 01:00:29,210
ANDI פנג: כן.

1231
01:00:29,210 --> 01:00:32,020
אז מה קורה
הוא שאתה בעצם

1232
01:00:32,020 --> 01:00:33,650
יוצרים מערך חדש לגמרי.

1233
01:00:33,650 --> 01:00:36,690
אז אתה יודע את זה, כאן, יש לי
שני מערכים בגודל 3, נכון?

1234
01:00:36,690 --> 01:00:39,600
אז אתה יודע שהמערך ממוין שלי
צריך להיות שישה אלמנטים.

1235
01:00:39,600 --> 01:00:42,270
אז אתה פשוט ליצור
סכום חדש של זיכרון.

1236
01:00:42,270 --> 01:00:44,270
אז אתה כמו סוג של
להיות בזבזן של זיכרון,

1237
01:00:44,270 --> 01:00:46,186
אבל זה לא משנה
כי זה כל כך קטן.

1238
01:00:46,186 --> 01:00:48,590
אז אתה מסתכל על 1
ואתה מסתכל על 2.

1239
01:00:48,590 --> 01:00:50,770
ואתה יודע שהוא פחות מ 1 2.

1240
01:00:50,770 --> 01:00:53,840
אז אתה יודע ש1 צריך ללכת ב
תחילת כל אלה.

1241
01:00:53,840 --> 01:00:55,850
>> אתה אפילו לא צריך
מסתכל על 3 ו5.

1242
01:00:55,850 --> 01:00:57,400
אז אתה יודע 1 הולך לשם.

1243
01:00:57,400 --> 01:00:59,300
אז אתה בעצם לכרות את 1.

1244
01:00:59,300 --> 01:01:00,370
זה, כמו, מת לנו.

1245
01:01:00,370 --> 01:01:03,690
אז פשוט יש לנו 2,
3, 5, ולאחר מכן 4 ו -6.

1246
01:01:03,690 --> 01:01:06,270
ואז אתה יודע את זה, אתה
להשוות את 4 ואת 2,

1247
01:01:06,270 --> 01:01:07,560
הו, 2 צריכים להיכנס לשם.

1248
01:01:07,560 --> 01:01:09,685
אז אתה פלופ הירידה של 2, אתה לכרות אותו.

1249
01:01:09,685 --> 01:01:12,060
אז אתה רק צריך 3
ו5 ב 4 ו 6.

1250
01:01:12,060 --> 01:01:14,650
ואתה פשוט לשמור לקצוץ אותו
עד ששמת אותם במערך.

1251
01:01:14,650 --> 01:01:17,110
>> קהל: אז אתה פשוט תמיד
השוואה [לא ברור]?

1252
01:01:17,110 --> 01:01:17,710
>> ANDI פנג: בדיוק.

1253
01:01:17,710 --> 01:01:19,590
אז במובן הזה, אתה
רק השוואה, במהות,

1254
01:01:19,590 --> 01:01:21,240
מספר אחד נגד המספר האחר.

1255
01:01:21,240 --> 01:01:22,990
וכי אתה יודע
שזה מסודרים,

1256
01:01:22,990 --> 01:01:24,350
לא צריך להסתכל דרך
כל המספרים.

1257
01:01:24,350 --> 01:01:25,870
אתה פשוט צריך להסתכל על הראשון.

1258
01:01:25,870 --> 01:01:27,582
ואז אתה יכול פשוט פלופ
אותם, כי אתה יודע ש

1259
01:01:27,582 --> 01:01:29,640
הם שייכים בו הם צריכים להיות שייכים.

1260
01:01:29,640 --> 01:01:31,030
כן.

1261
01:01:31,030 --> 01:01:32,920
שאלה טובה.

1262
01:01:32,920 --> 01:01:35,290
>> ואז אם מישהו מכם
הם קצת שאפתנים,

1263
01:01:35,290 --> 01:01:38,660
תרגיש חופשי להסתכל על קוד זה.

1264
01:01:38,660 --> 01:01:40,680
זהו למעשה
יישום פיזי

1265
01:01:40,680 --> 01:01:42,150
איך היינו לכתוב סוג מיזוג.

1266
01:01:42,150 --> 01:01:44,070
ואתה יכול לראות, זה קצר מאוד.

1267
01:01:44,070 --> 01:01:46,310
אבל הרעיונות שמאחורי
זה די מורכב.

1268
01:01:46,310 --> 01:01:50,865
אז אם אתה מרגיש כמו ציור את זה
בערב שיעורי הבית שלך, אל תהסס.

1269
01:01:50,865 --> 01:01:54,050

1270
01:01:54,050 --> 01:01:54,740
>> אוקיי.

1271
01:01:54,740 --> 01:01:58,070
אז דוד גם הלך על זה בהרצאה.

1272
01:01:58,070 --> 01:02:00,660
מה הם המקרה הטוב
runtimes, runtimes המקרה הגרועה ביותר,

1273
01:02:00,660 --> 01:02:05,680
וruntimes הצפויה מסוג המיזוג?

1274
01:02:05,680 --> 01:02:07,260
כמה שניות לחשוב.

1275
01:02:07,260 --> 01:02:11,198
זה די קשה, אבל סוג של
אינטואיטיבי אם אתה חושב על זה.

1276
01:02:11,198 --> 01:02:20,090

1277
01:02:20,090 --> 01:02:23,054
בסדר.

1278
01:02:23,054 --> 01:02:25,269
>> קהל: האם n יומן המקרה n הגרוע ביותר?

1279
01:02:25,269 --> 01:02:26,060
ANDI פנג: בדיוק.

1280
01:02:26,060 --> 01:02:29,380
ולמה זה n להיכנס n.

1281
01:02:29,380 --> 01:02:32,230
>> קהל: האם זה לא משום שהיא
הופך באופן אקספוננציאלי מהר יותר,

1282
01:02:32,230 --> 01:02:35,390
אז זה כמו פונקציה של ש
במקום פשוט להיות n

1283
01:02:35,390 --> 01:02:37,529
בריבוע או משהו?

1284
01:02:37,529 --> 01:02:38,320
ANDI פנג: בדיוק.

1285
01:02:38,320 --> 01:02:40,750
אז הסיבה
זמן ריצה על זה יומן n

1286
01:02:40,750 --> 01:02:44,310
n הוא הדבר משום מה אתה
עושה בכל הצעדים הללו?

1287
01:02:44,310 --> 01:02:46,190
אתה פשוט לקצוץ אותו לשניים, נכון?

1288
01:02:46,190 --> 01:02:48,750
ולכן כאשר אנחנו עושים
יומן, כל מה שהוא עושה

1289
01:02:48,750 --> 01:02:53,150
הוא חלוקת בעיה במחצית,
במחצית, במחצית, בחצי יותר.

1290
01:02:53,150 --> 01:02:56,430
ובמובן הזה, אתה יכול סוג
של לחסל את המודל ליניארי

1291
01:02:56,430 --> 01:02:57,510
כי אנחנו כבר משתמשים.

1292
01:02:57,510 --> 01:03:00,254
כי כשאתה קוצצים
דברים במחצית, זה יומן.

1293
01:03:00,254 --> 01:03:02,420
זה בדיוק מתמטי
דרך לייצג אותו.

1294
01:03:02,420 --> 01:03:06,310
>> ולבסוף, בסוף, אתה
רק עושה מעבר אחרון אחד דרך

1295
01:03:06,310 --> 01:03:07,930
לשים את כולם במטרה, נכון?

1296
01:03:07,930 --> 01:03:10,330
ולכן אם אתה רק צריך
לבדוק דבר אחד, זה n.

1297
01:03:10,330 --> 01:03:13,420
ואז אתה סוג של
הכפלת שני יחד.

1298
01:03:13,420 --> 01:03:17,660
אז זה כמו שיש לך שסופי
לבדוק עבור n כאן למטה עם יומן של n

1299
01:03:17,660 --> 01:03:18,390
פה למעלה.

1300
01:03:18,390 --> 01:03:21,060
ואם אתה להכפיל
שלהם, זה n להיכנס n.

1301
01:03:21,060 --> 01:03:26,100
>> וכך במקרה הגרוע ביותר והטוב ביותר
מקרה וצפוי כולם n להיכנס n.

1302
01:03:26,100 --> 01:03:27,943
זה גם כמו סוג אחר.

1303
01:03:27,943 --> 01:03:30,090
זה כמו סוג הבחירה
במובן זה שהיא

1304
01:03:30,090 --> 01:03:32,131
לא משנה מה שלך
רשימה היא, זה פשוט קורה

1305
01:03:32,131 --> 01:03:34,801
לעשות את אותו הדבר כל זמן.

1306
01:03:34,801 --> 01:03:35,300
אוקיי.

1307
01:03:35,300 --> 01:03:39,950
אז כפי שאתם יכולים לראות, למרות ש
מיני שכבר הלכו through-- n

1308
01:03:39,950 --> 01:03:41,660
בריבוע, זה לא יעיל מאוד.

1309
01:03:41,660 --> 01:03:47,060
ואפילו זה n יומן n הוא
לא יעיל ביותר.

1310
01:03:47,060 --> 01:03:49,720
אם אתם סקרנים,
יש מנגנונים מסוג

1311
01:03:49,720 --> 01:03:54,310
כי הם כל כך יעילים, כי הם
כמעט בעצם שטוח בזמן ריצה.

1312
01:03:54,310 --> 01:03:55,420
>> יש לך כמה יומן n של.

1313
01:03:55,420 --> 01:03:58,190
יש לך כמה יומן יומן n של.

1314
01:03:58,190 --> 01:04:00,330
אנחנו לא נוגעים בהם
בכיתה זו עכשיו.

1315
01:04:00,330 --> 01:04:02,663
אבל אם אתם סקרנים,
תרגיש חופשי google, מה

1316
01:04:02,663 --> 01:04:04,392
מנגנוני מיון יעילים ביותר.

1317
01:04:04,392 --> 01:04:06,350
אני לא יודע, יש
כמה אלה ממש מצחיקים,

1318
01:04:06,350 --> 01:04:09,860
like-- יש כמה באמת
מצחיקים אלה שאנשים עושים.

1319
01:04:09,860 --> 01:04:12,210
ואתה תוהה איך הם
אי פעם חשב על זה.

1320
01:04:12,210 --> 01:04:15,730
אז google, אם יש לך כמה חילוף
זמן, על, מה הן כמה דרכים מצחיקות

1321
01:04:15,730 --> 01:04:17,730
שאנשים-- כמו גם
אנשי ways-- יעילים

1322
01:04:17,730 --> 01:04:20,371
הצלחתי ליישם מיני.

1323
01:04:20,371 --> 01:04:20,870
אוקיי.

1324
01:04:20,870 --> 01:04:22,880
והנה רק תרשים קטן שימושי.

1325
01:04:22,880 --> 01:04:26,850
אני יודע שכולכם, לפני החידון ש0,
יהיה בחדר שלך כנראה מנסה

1326
01:04:26,850 --> 01:04:27,960
לשנן את זה.

1327
01:04:27,960 --> 01:04:30,940
אז זה נחמד שם בשבילכם.

1328
01:04:30,940 --> 01:04:37,120
רק אל תשכחו את ההיגיון שmade--
מדוע המספרים האלה היו מתרחשים.

1329
01:04:37,120 --> 01:04:39,870
אם אתה תמיד הולך לאיבוד, פשוט לעשות
בטוח שאתה יודע מה הם מיני.

1330
01:04:39,870 --> 01:04:40,820
ואתה יכול להפעיל דרך
שלהם בראש שלך

1331
01:04:40,820 --> 01:04:42,903
כדי להבין מדוע אלה
תשובות הן תשובות אלה.

1332
01:04:42,903 --> 01:04:46,250

1333
01:04:46,250 --> 01:04:47,600
>> בסדר.

1334
01:04:47,600 --> 01:04:49,680
אז אנחנו הולכים להעביר
ב, סוף סוף, לחיפוש.

1335
01:04:49,680 --> 01:04:51,638
כי כמו אלה שלך
שקראתי pset,

1336
01:04:51,638 --> 01:04:55,175
חיפוש הוא גם חלק מ
הבעיה של השבוע קובעת.

1337
01:04:55,175 --> 01:04:57,300
תתבקש ליישם
שני סוגים של חיפושים.

1338
01:04:57,300 --> 01:05:00,070
אחד הוא חיפוש ליניארי ו
אחד הוא חיפוש בינארי.

1339
01:05:00,070 --> 01:05:01,760
>> אז החיפוש ליניארי הוא קל למדי.

1340
01:05:01,760 --> 01:05:04,070
אתה רק רוצה לחפש אלמנט
של רשימה כדי לראות אם אתה מקבל את זה.

1341
01:05:04,070 --> 01:05:05,444
אתה פשוט צריך לחזר דרך.

1342
01:05:05,444 --> 01:05:08,170
ואם זה שווה משהו,
אתה יכול פשוט להחזיר אותו, נכון?

1343
01:05:08,170 --> 01:05:10,890
אבל אחד שאנחנו ביותר
מעוניין לדבר על

1344
01:05:10,890 --> 01:05:14,550
הוא החיפוש בינארי, תקין, שהוא
פרד ומשול מנגנון ש

1345
01:05:14,550 --> 01:05:18,190
דוד היה מפגין בהרצאה.

1346
01:05:18,190 --> 01:05:20,810
>> זכור דוגמא ספר טלפונים
שהוא ממשיך להעלות את,

1347
01:05:20,810 --> 01:05:23,960
אחד שהוא סוג של נאבק
קצת על זה בשנה האחרונה,

1348
01:05:23,960 --> 01:05:27,530
שבו אתה מחלק את הבעיה במחצית,
במחצית, במחצית, שוב ושוב,

1349
01:05:27,530 --> 01:05:30,730
עד שתמצא את מה שאתה מחפש?

1350
01:05:30,730 --> 01:05:33,727
ויש לך
כמו גם זמן ריצה של ש.

1351
01:05:33,727 --> 01:05:35,810
ואתה יכול לראות, זה
באופן משמעותי יעיל יותר

1352
01:05:35,810 --> 01:05:39,080
יותר מכל סוג אחר של חיפוש.

1353
01:05:39,080 --> 01:05:41,880
>> אז הדרך שאנחנו הייתם הולכים על
יישום חיפוש בינארי

1354
01:05:41,880 --> 01:05:46,510
הוא, אם היו לנו מערך,
מדד 0 עד 6, שבעה אלמנטים,

1355
01:05:46,510 --> 01:05:49,790
אנחנו יכולים להסתכל באמצע, right--
מצטער, אם השאלה שלנו first--

1356
01:05:49,790 --> 01:05:53,840
אם אנחנו רוצים לשאול את השאלה של, עושה
המערך מכיל את הרכיב של 7,

1357
01:05:53,840 --> 01:05:56,840
כמובן, להיות בני אדם, ושיש
כגון מערך קטן, קל לנו

1358
01:05:56,840 --> 01:05:58,210
לומר כן.

1359
01:05:58,210 --> 01:06:05,750
אבל הדרך ליישום בינארי
חיפוש יהיה לחפש באמצע.

1360
01:06:05,750 --> 01:06:08,020
>> אנו יודעים כי מדד 3 הוא
האמצע, כי אנחנו

1361
01:06:08,020 --> 01:06:09,270
יודע שיש שבעה אלמנטים.

1362
01:06:09,270 --> 01:06:10,670
מה 7 חלקי 2?

1363
01:06:10,670 --> 01:06:12,850
אתה יכול לכרות את ש1 נוסף.

1364
01:06:12,850 --> 01:06:14,850
יש לך 3 באמצע.

1365
01:06:14,850 --> 01:06:17,590
אז הוא מערך של 3 שווה ל -7?

1366
01:06:17,590 --> 01:06:18,900
זה לא, נכון?

1367
01:06:18,900 --> 01:06:21,050
אבל אנחנו יכולים לעשות כמה בדיקות.

1368
01:06:21,050 --> 01:06:25,380
האם מערך של 3 פחות מ 7 או
הוא מערך של 3 יותר מ 7?

1369
01:06:25,380 --> 01:06:27,240
>> ואנחנו יודעים שזה פחות מ 7.

1370
01:06:27,240 --> 01:06:30,259
אז אנחנו יודעים את זה, אה, זה חייב
לא יהיה במחצית השמאלית.

1371
01:06:30,259 --> 01:06:32,300
אנחנו יודעים שזה חייב להיות
במחצית תקין, נכון?

1372
01:06:32,300 --> 01:06:34,662
אז אנחנו יכולים רק לכרות את מחצית המערך.

1373
01:06:34,662 --> 01:06:36,370
אפילו אין לנו ל
מסתכל על זה יותר.

1374
01:06:36,370 --> 01:06:38,711
כי אנחנו יודעים ש
מחצית problem--

1375
01:06:38,711 --> 01:06:41,210
אנחנו יודעים שהתשובה היא ב
המחצית הימנית של הבעיה שלנו.

1376
01:06:41,210 --> 01:06:42,580
אז אנחנו פשוט מסתכלים על זה עכשיו.

1377
01:06:42,580 --> 01:06:44,860
>> אז עכשיו אנחנו מסתכל על
אמצע מה שנשאר.

1378
01:06:44,860 --> 01:06:46,880
מדד זה 5.

1379
01:06:46,880 --> 01:06:50,200
אנו עושים את אותו הסימון שוב
ואנחנו רואים שזה קטן יותר.

1380
01:06:50,200 --> 01:06:52,050
אז אנחנו מסתכלים לצד השמאל של זה.

1381
01:06:52,050 --> 01:06:53,430
ואז אנחנו רואים סימון ש.

1382
01:06:53,430 --> 01:06:57,600
האם ערך המערך ב
מדד 4 שווה ל -7?

1383
01:06:57,600 --> 01:06:58,260
זה.

1384
01:06:58,260 --> 01:07:03,580
אז אנחנו יכולים לחזור אמיתיים, משום ש
מצאנו את הערך ברשימה שלנו.

1385
01:07:03,580 --> 01:07:06,738
האם הדרך שעברתי
זה הגיוני לכולם?

1386
01:07:06,738 --> 01:07:08,760
אוקיי.

1387
01:07:08,760 --> 01:07:11,670
אני אתן לכם אולי, כמו,
שלוש, ארבע דקות כדי להבין

1388
01:07:11,670 --> 01:07:13,270
איך פסאודו קוד זה ב.

1389
01:07:13,270 --> 01:07:18,070
>> אז אני מניח ביקשתי ממך לכתוב
חיפוש פונקציה שנקרא () שחזרה

1390
01:07:18,070 --> 01:07:20,640
ערך, ערך בוליאני,
זה היה נכון או false-- כמו,

1391
01:07:20,640 --> 01:07:22,970
נכון אם מצא
ערך, שקר אם לא.

1392
01:07:22,970 --> 01:07:25,230
ואז אתה היה
עבר בשוויך

1393
01:07:25,230 --> 01:07:28,410
חיפשנו לערכים, ש
הוא array-- הו, אני בהחלט לשים

1394
01:07:28,410 --> 01:07:29,410
שבמקום הלא נכון.

1395
01:07:29,410 --> 01:07:29,580
אוקיי.

1396
01:07:29,580 --> 01:07:31,829
בכל מקרה, שיהיה לי
היה בצד הימין של ערכים.

1397
01:07:31,829 --> 01:07:36,280
ואז int n הוא המספר
אלמנטים במערך ש.

1398
01:07:36,280 --> 01:07:39,430
איך היית הולך על ניסיון
לפסאודו קוד בעיה שב?

1399
01:07:39,430 --> 01:07:41,630
אני אתן לך בחורים כמו
שלוש דקות לעשות את זה.

1400
01:07:41,630 --> 01:08:00,137

1401
01:08:00,137 --> 01:08:02,595
לא, אני חושב שיש only--
כן, יש אחד ממש עד כאן.

1402
01:08:02,595 --> 01:08:03,261
קהל: האם אני יכול?

1403
01:08:03,261 --> 01:08:04,388
ANDI פנג: כן, יש לי אותך.

1404
01:08:04,388 --> 01:08:09,410

1405
01:08:09,410 --> 01:08:11,050
האם זה עובד?

1406
01:08:11,050 --> 01:08:12,290
בסדר מגניב.

1407
01:08:12,290 --> 01:10:43,590

1408
01:10:43,590 --> 01:10:44,720
>> אוקיי.

1409
01:10:44,720 --> 01:10:47,630
כל הבחורים הנכונים, אנחנו
הולך לרסן אותו ב.

1410
01:10:47,630 --> 01:10:49,730
אוקיי.

1411
01:10:49,730 --> 01:10:54,020
אז תניח שיש לנו זה יפה
מערך קטן עם ערכי n בזה.

1412
01:10:54,020 --> 01:10:55,170
אני לא לצייר את הקווים.

1413
01:10:55,170 --> 01:10:58,649
אבל איך היינו הולכים על
מנסה לכתוב את זה?

1414
01:10:58,649 --> 01:11:00,440
האם מישהו רוצה
תן לי את השורה הראשונה?

1415
01:11:00,440 --> 01:11:02,814
אם אתה רוצה לתת לי
הקו הראשון של פסאודו קוד זה.

1416
01:11:02,814 --> 01:11:06,563

1417
01:11:06,563 --> 01:11:08,430
>> קהל: [לא ברור]

1418
01:11:08,430 --> 01:11:10,138
קהל: היית רוצה
ללחזר through--

1419
01:11:10,138 --> 01:11:11,094
קהל: רק עוד ללולאה?

1420
01:11:11,094 --> 01:11:11,760
קהל: --for.

1421
01:11:11,760 --> 01:11:15,880

1422
01:11:15,880 --> 01:11:17,780
>> ANDI פנג: אז זה אחד זה קצת מסובך.

1423
01:11:17,780 --> 01:11:23,130
חושב שאתה רוצה על--
להמשיך לרוץ לולאה זה

1424
01:11:23,130 --> 01:11:27,950
שוב ושוב עד מתי?

1425
01:11:27,950 --> 01:11:30,819
>> קהל: עד [לא ברור]
הערך שווה לערך זה.

1426
01:11:30,819 --> 01:11:31,610
ANDI פנג: בדיוק.

1427
01:11:31,610 --> 01:11:33,900
אז אתה יכול בעצם רק write--
אנחנו אפילו יכולים לפשט את זה יותר.

1428
01:11:33,900 --> 01:11:35,630
אנחנו רק יכולים לעשות לולאה בזמן, נכון?

1429
01:11:35,630 --> 01:11:39,380
אז אתה יכול רק צריך loop--
אנחנו יודעים שזה זמן.

1430
01:11:39,380 --> 01:11:42,850
אבל לעכשיו, אני הולך
לומר "לולאה" - דרך מה?

1431
01:11:42,850 --> 01:11:46,640
לולאת until-- מה היא
מצב הסיום שלנו?

1432
01:11:46,640 --> 01:11:47,510
אני חושב ששמעתי אותו.

1433
01:11:47,510 --> 01:11:48,530
שמעתי מישהו אומר את זה.

1434
01:11:48,530 --> 01:11:51,255
>> קהל: ערכים שווים אמצע.

1435
01:11:51,255 --> 01:11:52,255
ANDI פנג: תגיד את זה שוב.

1436
01:11:52,255 --> 01:11:54,470
קהל: או, עד
ערך שאתה מחפש

1437
01:11:54,470 --> 01:11:58,470
לשווה לערך האמצעי.

1438
01:11:58,470 --> 01:12:00,280
>> ANDI פנג: מה אם זה לא שם?

1439
01:12:00,280 --> 01:12:03,113
מה אם הערך שאתה מחפש
להוא לא ממש במערך הזה?

1440
01:12:03,113 --> 01:12:05,890
קהל: אתה חוזר 1.

1441
01:12:05,890 --> 01:12:08,850
>> ANDI פנג: אבל מה שאנחנו רוצים
לולאה עד אם יש לנו מצב?

1442
01:12:08,850 --> 01:12:09,350
כן.

1443
01:12:09,350 --> 01:12:11,239
>> קהל: עד שיש רק ערך אחד?

1444
01:12:11,239 --> 01:12:13,530
ANDI פנג: אתה יכול לולאה
until-- כך שאתה יודע שאתה

1445
01:12:13,530 --> 01:12:15,714
הולך להיות ערך מקסימום, נכון?

1446
01:12:15,714 --> 01:12:18,130
ואתה יודע שאתה הולך
יש ערך דק ', נכון?

1447
01:12:18,130 --> 01:12:20,379
כי גם, זה משהו ש
שכחתי להגיד לפני,

1448
01:12:20,379 --> 01:12:22,640
כי משהו שהוא
ביקורתי על חיפוש בינארי

1449
01:12:22,640 --> 01:12:24,182
הוא שהמערך שלך כבר מסודרים.

1450
01:12:24,182 --> 01:12:26,973
כי אין דרך לעשות
זה אם הם ערכים רק אקראיים.

1451
01:12:26,973 --> 01:12:29,190
אתה לא יודע אם זה אחד
גדול יותר מאשר אחרים, נכון?

1452
01:12:29,190 --> 01:12:32,720
>> אז אתה יודע שהמקסימום שלך ו
דקות שלך נמצאות כאן, נכון?

1453
01:12:32,720 --> 01:12:35,590
אם אתה הולך להיות התאמה
המקסימום שלך בדקות שלך וmid--

1454
01:12:35,590 --> 01:12:38,470
בואו פשוט להניח שלך
ערך אמצע הוא כאן-- תקין

1455
01:12:38,470 --> 01:12:43,910
אתה הולך בעצם
לולאה עד המינימום שלך הוא

1456
01:12:43,910 --> 01:12:47,510
בערך כמו המקסימום שלך, נכון, או
אם המקסימום שלך הוא לא אותו הדבר כמו דקות שלך.

1457
01:12:47,510 --> 01:12:48,040
נכון?

1458
01:12:48,040 --> 01:12:51,340
כי כשזה קורה, אתה יודע ש
סופו של דבר שפגעת באותו הערך.

1459
01:12:51,340 --> 01:12:59,135
אז אתה רוצה לולאה עד דקות שלך
הוא פחות או שווה צריכה-- אופס,

1460
01:12:59,135 --> 01:13:01,510
לא פחות מ או שווה ל,
הדרך אחרת around-- המקסימום היא.

1461
01:13:01,510 --> 01:13:15,110

1462
01:13:15,110 --> 01:13:16,160
>> האם זה הגיוני?

1463
01:13:16,160 --> 01:13:18,810
לקחתי כמה ניסיונות כדי לקבל זכות ש.

1464
01:13:18,810 --> 01:13:21,869
אבל לולאה עד הערך המרבי שלך
הוא למעשה כמעט פחות

1465
01:13:21,869 --> 01:13:23,410
או שווה למינימום שלך, נכון?

1466
01:13:23,410 --> 01:13:25,201
זה היה רגע שאתה יודע
כי אתה כבר התכנס.

1467
01:13:25,201 --> 01:13:29,290
קהל: מתי המרבי שלך
ערך יהיה פחות מהמינימום?

1468
01:13:29,290 --> 01:13:31,040
ANDI פנג: אם אתה שומר
התאמתו, ש

1469
01:13:31,040 --> 01:13:32,380
זה מה שאנחנו הולכים
להיות עושה בזה.

1470
01:13:32,380 --> 01:13:33,460
האם זה הגיוני?

1471
01:13:33,460 --> 01:13:35,750
מינימום והמקסימום הם רק
מספרים שלמים שאנחנו כנראה

1472
01:13:35,750 --> 01:13:39,260
הולך רוצה ליצור כדי לשמור
אחר שבו אנחנו מחפשים.

1473
01:13:39,260 --> 01:13:41,790
כיוון שהמערך קיים
בלי קשר למה שאנחנו עושים.

1474
01:13:41,790 --> 01:13:45,030
כמו, אנחנו לא ממש פיזי
עריפת המערך, נכון?

1475
01:13:45,030 --> 01:13:47,261
אנחנו רק התאמה
שבו אנחנו מחפשים.

1476
01:13:47,261 --> 01:13:48,136
האם זה הגיוני?

1477
01:13:48,136 --> 01:13:48,472
>> קהל: כן.

1478
01:13:48,472 --> 01:13:49,110
>> ANDI פנג: אישור.

1479
01:13:49,110 --> 01:13:57,090
אז אם זה המצב ללולאה שלנו,
מה שאנחנו רוצים בתוך לולאה זה?

1480
01:13:57,090 --> 01:13:58,700
מה שאנחנו הולכים להיות שרוצים לעשות?

1481
01:13:58,700 --> 01:14:02,390
אז עכשיו, יש לנו
מקסימום ודקות, נכון,

1482
01:14:02,390 --> 01:14:04,962
כנראה שנוצר כאן איפשהו.

1483
01:14:04,962 --> 01:14:07,170
אנחנו הולכים כנראה לרוצים
למצוא אמצע, נכון?

1484
01:14:07,170 --> 01:14:08,450
איך אנחנו הולכים להיות
תוכל למצוא את האמצע?

1485
01:14:08,450 --> 01:14:09,491
מה mathematical--

1486
01:14:09,491 --> 01:14:11,079
קהל: מקס פלוס דקות מחולקות ב -2.

1487
01:14:11,079 --> 01:14:11,870
ANDI פנג: בדיוק.

1488
01:14:11,870 --> 01:14:20,300

1489
01:14:20,300 --> 01:14:21,620
האם זה הגיוני?

1490
01:14:21,620 --> 01:14:25,780
ואתם מבינים למה אנחנו
לא רק use-- למה עשינו את זה

1491
01:14:25,780 --> 01:14:27,850
במקום לעשות רק מחולק n על ידי 2?

1492
01:14:27,850 --> 01:14:30,310
זה בגלל n הוא ערך
זה הולך להישאר אותו הדבר.

1493
01:14:30,310 --> 01:14:30,979
נכון?

1494
01:14:30,979 --> 01:14:34,020
אבל כפי שאנו להתאים המינימום שלנו ו
ערכים מרביים, שהם הולכים לשנות.

1495
01:14:34,020 --> 01:14:36,040
כתוצאה מכך, באמצע שלנו
הולך לשנות מדי.

1496
01:14:36,040 --> 01:14:37,873
אז זאת הסיבה שאנחנו רוצים
לעשות את זה נכון כאן.

1497
01:14:37,873 --> 01:14:38,510
אוקיי.

1498
01:14:38,510 --> 01:14:41,600
>> ולאחר מכן, החברה ש
שמצאנו our-- כן.

1499
01:14:41,600 --> 01:14:44,270
>> קהל: רק question-- מהיר
כשאתה אומר דקות ומקסימום,

1500
01:14:44,270 --> 01:14:46,410
אנחנו מניחים ש
זה כבר מסודרים?

1501
01:14:46,410 --> 01:14:48,400
>> ANDI פנג: כן, זה בעצם
תנאי מוקדם לחיפוש בינארי,

1502
01:14:48,400 --> 01:14:49,816
כי יש לך לדעת שזה מסודרים.

1503
01:14:49,816 --> 01:14:53,660
ולכן סוג, אתה כותב בך
בעיה להגדיר לפני החיפוש בינארי שלך.

1504
01:14:53,660 --> 01:14:55,910
אוקיי.

1505
01:14:55,910 --> 01:14:58,876
אז עכשיו שאנחנו יודעים איפה נקודת האמצע שלנו
הוא, מה אתה רוצה לעשות כאן?

1506
01:14:58,876 --> 01:15:01,789

1507
01:15:01,789 --> 01:15:04,319
>> קהל: אנחנו רוצים להשוות
כי לשני.

1508
01:15:04,319 --> 01:15:05,110
ANDI פנג: בדיוק.

1509
01:15:05,110 --> 01:15:12,280
אז אתה הולך להשוות
אמצע לשווי, נכון?

1510
01:15:12,280 --> 01:15:14,900

1511
01:15:14,900 --> 01:15:18,670
ומה זה אומר לי
שלנו כאשר אנו משווים?

1512
01:15:18,670 --> 01:15:22,226
מה שאנחנו רוצים לעשות אחר כך?

1513
01:15:22,226 --> 01:15:25,389
>> קהל: אם הערך הוא גדול יותר
מהאמצע, אנחנו רוצים לחתוך אותו.

1514
01:15:25,389 --> 01:15:26,180
ANDI פנג: בדיוק.

1515
01:15:26,180 --> 01:15:33,940
אז אם הערך הוא גדול יותר
מהאמצע, אנחנו

1516
01:15:33,940 --> 01:15:36,550
הולך רוצה לשנות תנאים אלו
מינימום ומקסס, נכון?

1517
01:15:36,550 --> 01:15:38,980
מה אנחנו רוצים לשנות?

1518
01:15:38,980 --> 01:15:42,145
אז אם אנחנו יודעים את הערך הוא איפשהו
כאן, מה אתה עושה לנו לשנות?

1519
01:15:42,145 --> 01:15:44,758
אנחנו רוצים לשנות אותנו
מינימום להיות באמצע, נכון?

1520
01:15:44,758 --> 01:15:49,420

1521
01:15:49,420 --> 01:15:54,292
ולאחר מכן אחר, אם זה בזה
מחצית, מה אנחנו רוצים לשנות?

1522
01:15:54,292 --> 01:15:55,306
>> קהל: המרבי שלך.

1523
01:15:55,306 --> 01:15:55,972
ANDI פנג: כן.

1524
01:15:55,972 --> 01:16:02,597

1525
01:16:02,597 --> 01:16:04,680
ואז אתה פשוט הולך
כדי לשמור על הלולאה, נכון?

1526
01:16:04,680 --> 01:16:08,920
כי עכשיו, לאחר איטרציה אחת
דרך, יש לך מקסימום כאן.

1527
01:16:08,920 --> 01:16:10,760
ואז אתה יכול לחשב מחדש אמצע.

1528
01:16:10,760 --> 01:16:11,990
ואז אתה יכול להשוות.

1529
01:16:11,990 --> 01:16:14,766
ואתה הולך להמשיך
עד דקות ומקסס

1530
01:16:14,766 --> 01:16:15,890
יש בעצם התכנס.

1531
01:16:15,890 --> 01:16:17,890
וזה כאשר אתה יודע ש
שפגעת בסופו של אותו.

1532
01:16:17,890 --> 01:16:20,280
וגם מצאת את זה
או שיש לך לא בשלב זה.

1533
01:16:20,280 --> 01:16:23,170
>> האם זה הגיוני לכולם?

1534
01:16:23,170 --> 01:16:26,020

1535
01:16:26,020 --> 01:16:26,770
אוקיי.

1536
01:16:26,770 --> 01:16:27,900
זה די חשוב,
כי יהיה לך

1537
01:16:27,900 --> 01:16:29,760
כדי לכתוב את זה בערב את הקוד שלך.

1538
01:16:29,760 --> 01:16:32,660
אבל יש לכם די טוב
תחושה של מה שאתה צריך לעשות,

1539
01:16:32,660 --> 01:16:34,051
שזה טוב.

1540
01:16:34,051 --> 01:16:34,550
אוקיי.

1541
01:16:34,550 --> 01:16:38,840
אז יש לנו כשבע
דקת סעיף.

1542
01:16:38,840 --> 01:16:43,170
אז אנחנו הולכים לדבר על
pset זה שאנחנו אעשה.

1543
01:16:43,170 --> 01:16:46,410
אז pset מחולק לשני חצאים.

1544
01:16:46,410 --> 01:16:50,230
המחצית הראשונה כרוכה
יישום ממצא

1545
01:16:50,230 --> 01:16:54,210
שבו אתה כותב חיפוש ליניארי,
חיפוש בינארי, ואלגוריתם מיון.

1546
01:16:54,210 --> 01:16:56,690
>> אז זה הוא ראשון
זמן בpset בי

1547
01:16:56,690 --> 01:17:00,050
נהיה לתת לכם את מה שנקרא
קוד הפצה, שהוא קוד

1548
01:17:00,050 --> 01:17:02,740
שיש לנו מראש בכתב,
אבל רק עזבתי כמה חתיכות מ

1549
01:17:02,740 --> 01:17:04,635
כדי שתוכל לסיים את הכתיבה.

1550
01:17:04,635 --> 01:17:07,510
אז אתם, כשאתם מסתכלים על זה
קוד, אתה עלול לקבל הפחדת באמת.

1551
01:17:07,510 --> 01:17:08,630
אם אתה רק רוצה, אהה, אני
לא יודע מה שהוא עושה,

1552
01:17:08,630 --> 01:17:11,670
אני לא יודע, כמו, שנראה
כל כך מסובך, אהה, להירגע.

1553
01:17:11,670 --> 01:17:12,170
זה בסדר.

1554
01:17:12,170 --> 01:17:12,930
קראו את המפרט.

1555
01:17:12,930 --> 01:17:16,920
המפרט יסביר לך בדיוק
מה כל התוכניות האלה עושים.

1556
01:17:16,920 --> 01:17:20,560
>> לדוגמא, generate.c היא תכנית
שיבוא עם pset.

1557
01:17:20,560 --> 01:17:24,060
אתה באמת לא צריך לגעת בו, אבל
אתה צריך להבין מה הוא עושה.

1558
01:17:24,060 --> 01:17:28,550
וgenerate.c, כל זה עושה הוא
או יצירת מספרים אקראיים

1559
01:17:28,550 --> 01:17:32,400
או שאתה יכול לתת לו זרע, כמו
מספר מראש שזה לוקח,

1560
01:17:32,400 --> 01:17:34,140
והוא מייצר יותר מספרים.

1561
01:17:34,140 --> 01:17:37,170
אז יש דרך מסוימת ל
ליישם generate.c בי

1562
01:17:37,170 --> 01:17:42,760
אתה יכול פשוט להפוך חבורה של מספרים
כדי שתוכל לבדוק את השיטות האחרות שלך על.

1563
01:17:42,760 --> 01:17:45,900
>> אז אם אתה רוצה, ל
למשל, לבדוק את הממצא שלך,

1564
01:17:45,900 --> 01:17:48,970
היית רוצה לרוץ generate.c,
ליצור חבורה של מספרים,

1565
01:17:48,970 --> 01:17:50,880
ולאחר מכן להפעיל פונקצית העוזרים שלך.

1566
01:17:50,880 --> 01:17:53,930
פונקצית העוזרים שלך שבו אתה נמצא
למעשה כתיבת קוד פיזי.

1567
01:17:53,930 --> 01:17:59,330
ולחשוב על עוזרים כקובץ ספרייה
אתה כותב מגלים קורא.

1568
01:17:59,330 --> 01:18:02,950
וכך בתוך helpers.c, תמצאו
לעשות חיפוש ומיון.

1569
01:18:02,950 --> 01:18:06,500
>> ואז אתה הולך למהות
פשוט לשים את כולם יחד.

1570
01:18:06,500 --> 01:18:10,350
המפרט יגיד לך איך
לשים את זה בשורת הפקודה.

1571
01:18:10,350 --> 01:18:14,880
ואתה יכול לבדוק אם
לא הסוג והחיפוש שלך עובדים.

1572
01:18:14,880 --> 01:18:15,870
מגניב.

1573
01:18:15,870 --> 01:18:18,720
והאם מישהו כבר התחיל
בעיות או שאלות נתקלו

1574
01:18:18,720 --> 01:18:20,520
יש להם עכשיו עם זה?

1575
01:18:20,520 --> 01:18:21,020
אוקיי.

1576
01:18:21,020 --> 01:18:21,476
>> קהל: המתן.

1577
01:18:21,476 --> 01:18:21,932
יש לי שאלה.

1578
01:18:21,932 --> 01:18:22,844
>> ANDI פנג: כן.

1579
01:18:22,844 --> 01:18:28,390
>> קהל: אז התחלתי לעשות
החיפוש ליניארי בhelpers.c

1580
01:18:28,390 --> 01:18:29,670
וזה לא היה באמת עובד.

1581
01:18:29,670 --> 01:18:34,590
אבל אז מאוחר יותר, התברר לי שאנחנו פשוט
צריך למחוק אותו ולעשות חיפוש בינארי.

1582
01:18:34,590 --> 01:18:36,991
אז זה משנה אם זה לא עובד?

1583
01:18:36,991 --> 01:18:39,700

1584
01:18:39,700 --> 01:18:41,510
>> ANDI פנג: תשובה קצרה היא לא.

1585
01:18:41,510 --> 01:18:42,642
אבל מאז אנחנו not--

1586
01:18:42,642 --> 01:18:44,350
קהל: אבל אף אחד לא
בדיקה בפועל.

1587
01:18:44,350 --> 01:18:46,058
ANDI פנג: אנחנו לעולם לא
הולך לראות את זה.

1588
01:18:46,058 --> 01:18:49,590
אבל אתה כנראה רוצה לעשות
בטוח החיפוש שלך עובד.

1589
01:18:49,590 --> 01:18:51,700
כי אם ליניארי שלך
חיפוש לא עובד,

1590
01:18:51,700 --> 01:18:54,410
אז רוב הסיכויים שלך בינארי
החיפוש הוא לא הולך לעבודה גם כן.

1591
01:18:54,410 --> 01:18:56,646
כי יש לך דומה
היגיון בשניהם.

1592
01:18:56,646 --> 01:18:58,020
ולא, זה לא ממש משנה.

1593
01:18:58,020 --> 01:19:01,300
אז רק אלה שאתה תהפוך
בהם סוג והחיפוש בינארי.

1594
01:19:01,300 --> 01:19:02,490
כן.

1595
01:19:02,490 --> 01:19:06,610
>> וגם, הרבה ילדים היו
מנסה לקמפל helpers.c.

1596
01:19:06,610 --> 01:19:09,550
אתה לא רשאי למעשה
כדי לעשות את זה, כי helpers.c

1597
01:19:09,550 --> 01:19:11,200
אין פונקציה העיקרית.

1598
01:19:11,200 --> 01:19:13,550
ואז אתה רק צריך
להיות בעצם קומפילציה

1599
01:19:13,550 --> 01:19:18,670
ליצור ולמצוא, כי למצוא שיחות
helpers.c והפונקציות בתוכו.

1600
01:19:18,670 --> 01:19:20,790
אז זה עושה את הניפוי
קוץ בתחת.

1601
01:19:20,790 --> 01:19:22,422
אבל זה מה שאנחנו צריכים לעשות.

1602
01:19:22,422 --> 01:19:23,880
קהל: אתה פשוט להפוך את הכל, נכון?

1603
01:19:23,880 --> 01:19:27,290
ANDI פנג: אתה יכול פשוט
לעשות את כל וכן, כן.

1604
01:19:27,290 --> 01:19:28,060
אוקיי.

1605
01:19:28,060 --> 01:19:32,570
אז זהו זה במונחים של מה ש
pset מבקש כל מה שאתה צריך לעשות.

1606
01:19:32,570 --> 01:19:35,160
אם יש לך שאלות, מרגיש
חופשי לשאול אותי אחרי הסעיף.

1607
01:19:35,160 --> 01:19:37,580
אני אהיה כאן ל, כמו, 20 דקות.

1608
01:19:37,580 --> 01:19:40,500
>> וכן, pset של
באמת לא כל כך נורא.

1609
01:19:40,500 --> 01:19:41,680
אתם צריכים להיות בסדר.

1610
01:19:41,680 --> 01:19:43,250
אלה, רק לעקוב אחר הנחיות.

1611
01:19:43,250 --> 01:19:47,840
יש סוג של תחושה, מבחינה לוגית, מה
צריך להיות קורה ואתה תהיה בסדר.

1612
01:19:47,840 --> 01:19:48,690
אל תפחדו יותר מדי.

1613
01:19:48,690 --> 01:19:50,220
יש הרבה של קוד
כבר כתוב שם.

1614
01:19:50,220 --> 01:19:53,011
אל תפחדו גם אם לא
להבין מה כל זה אומר.

1615
01:19:53,011 --> 01:19:54,749
אם זה הרבה, זה לגמרי בסדר.

1616
01:19:54,749 --> 01:19:55,790
ולבוא לשעתי עבודה.

1617
01:19:55,790 --> 01:19:57,520
אנו נעזור לך להעיף מבט.

1618
01:19:57,520 --> 01:20:00,810
>> קהל: עם תוספת
פונקציות, אנחנו נראים האלה?

1619
01:20:00,810 --> 01:20:03,417
>> ANDI פנג: כן, אלה הם בקוד.

1620
01:20:03,417 --> 01:20:05,750
במשחק של 15, חצי מ
זה כבר נכתב בשבילך.

1621
01:20:05,750 --> 01:20:09,310
אז פונקציות אלה
כבר בקוד.

1622
01:20:09,310 --> 01:20:12,020
כן.

1623
01:20:12,020 --> 01:20:12,520
בסדר.

1624
01:20:12,520 --> 01:20:14,000
ובכן, בהצלחה.

1625
01:20:14,000 --> 01:20:15,180
זה יום מגעיל.

1626
01:20:15,180 --> 01:20:19,370
אז אני מקווה שאתם לא מרגישים יותר מדי
רע להישאר בפנים וקידוד.

1627
01:20:19,370 --> 01:20:22,133