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

2
00:00:06,370 --> 00:00:08,150
>> ג'ייסון הירשהורן: ברוכים הבאים
לשלושה בשבוע, כולם.

3
00:00:08,150 --> 00:00:11,650
יש לנו עסוק אך מרגש
סעיף לפנינו.

4
00:00:11,650 --> 00:00:17,010
אז קודם כל, בגלל שאנחנו עשינו כמה
התקדמות עם, כמובן, אבל אנחנו עדיין

5
00:00:17,010 --> 00:00:20,570
יש הרבה למידה שנותר לעשות, אני
הולך להראות לכם חבר 'ה כמה משאבים

6
00:00:20,570 --> 00:00:24,160
שצריך להוכיח להיות מאוד
מועיל כאשר אתה מתקרב לא רק שלך

7
00:00:24,160 --> 00:00:28,130
בעיה קובעת, אלא גם לעכל את כל
את החומר אנחנו נותנים לכם חבר 'ה ב

8
00:00:28,130 --> 00:00:30,800
הרצאות ומכנסיים קצרים וחתך.

9
00:00:30,800 --> 00:00:34,790
>> ואז אנחנו הולכים לבלות את 20 הראשונים
ל25 דקות של הקטע הולך על

10
00:00:34,790 --> 00:00:38,630
GDB, שאתה יכול או לא יכול להיות
משמש בשלב זה, אבל זה

11
00:00:38,630 --> 00:00:42,570
כלי מועיל מאוד שיהיה
לעזור לך באגים בתוכניות שלך.

12
00:00:42,570 --> 00:00:46,060
הרבה ייתכן שהשתמש בprintf
אמצע התכנית שלך כדי להבין

13
00:00:46,060 --> 00:00:47,430
מה משתנה שווה.

14
00:00:47,430 --> 00:00:52,060
GDB הוא אפילו טוב יותר מאשר printf ו
לא לדפוק את הקוד שלך, כי אתה

15
00:00:52,060 --> 00:00:53,320
להריץ אותו על קובץ הפעלה.

16
00:00:53,320 --> 00:00:56,500
אז אנחנו מתכוונים לעבור על 10 מועילים ביותר
פקודות שאתה צריך בשביל GDB, ואנחנו

17
00:00:56,500 --> 00:01:00,540
הולך על תרגיל יחד כך
בבעיה להגדיר שלוש ומעבר, לך

18
00:01:00,540 --> 00:01:03,320
ניתן להשתמש GDB כדי לעזור באגים
התוכניות שלך.

19
00:01:03,320 --> 00:01:06,420
ולבסוף, אנחנו הולכים לעבור על כמה
מיון וחיפוש אלגוריתמים

20
00:01:06,420 --> 00:01:10,590
שראית בהרצאה, ואנחנו
הולך בעצם קוד, ולא רק

21
00:01:10,590 --> 00:01:17,360
חיפוש בינארי pseudocode, אבל קוד,
מיון בועות, ומיון בחירה.

22
00:01:17,360 --> 00:01:20,090
>> אז קודם כל, אני רוצה ללכת
על המשאבים.

23
00:01:20,090 --> 00:01:23,530
זו רשימה מקיפה, וזה
גופן קטן יותר כי היה לי הרבה מה

24
00:01:23,530 --> 00:01:24,390
תתאים כאן.

25
00:01:24,390 --> 00:01:26,950
אבל אלה לא רק יעזרו לך,
שוב, עם סטי הבעיה ו

26
00:01:26,950 --> 00:01:30,760
מידע לעכל שלמדת, אבל
בהחלט, הגיע זמן חידון, יהיו אלה

27
00:01:30,760 --> 00:01:32,130
להיות מועיל מאוד.

28
00:01:32,130 --> 00:01:34,700
אז קודם כל, סיכומים.

29
00:01:34,700 --> 00:01:39,480
אם אתה הולך לcs50.net/lectures ו
לגלול לשבוע הספציפי ויום,

30
00:01:39,480 --> 00:01:43,120
אתה תראה שיש הערות לכל
הרצאה, שהוא לא פשוט

31
00:01:43,120 --> 00:01:47,250
תמליל, אך גרסה ערוכה של
מה היה מכוסה בהרצאה עם קוד

32
00:01:47,250 --> 00:01:49,610
קטעים ופיסות מועילות אחרות.

33
00:01:49,610 --> 00:01:52,220
אני מאוד ממליץ ללכת על פני אלה.

34
00:01:52,220 --> 00:01:55,340
ואז, כמו גם, יש קוד המקור
זמין מכל הרצאה.

35
00:01:55,340 --> 00:02:00,050
ושוב, מגלשות אלה תהיינה גם
זמין באופן מקוון ב cs50.net/sections

36
00:02:00,050 --> 00:02:01,480
בערב זה.

37
00:02:01,480 --> 00:02:06,860
>> אז שני הם המכנסיים הקצרים בכל שבוע כי
נושאי כיסוי, בדרך כלל 5 עד 15

38
00:02:06,860 --> 00:02:08,090
דקות אורך.

39
00:02:08,090 --> 00:02:12,310
ואלה אני מקווה שינתנו לך
פריימר הגדול בנושאים שונים.

40
00:02:12,310 --> 00:02:12,870
שלישי -

41
00:02:12,870 --> 00:02:16,370
וזה זה מותג החדש
שנה - הוא study.cs50.net.

42
00:02:16,370 --> 00:02:20,110
אם לא בדק את זה, אני
מאוד ממליץ לך לעשות זאת.

43
00:02:20,110 --> 00:02:21,100
אתה מקבל לבחור נושא.

44
00:02:21,100 --> 00:02:23,040
יש לנו עשרות נושאים על שם.

45
00:02:23,040 --> 00:02:24,770
כך למשל, אתה בוחר פונקציות.

46
00:02:24,770 --> 00:02:27,270
זה נותן לך כמה שקופיות
ומציין בפונקציות.

47
00:02:27,270 --> 00:02:31,190
אלה הם למעשה את השקופיות שTFS
מוזמנים להשתמש בנו

48
00:02:31,190 --> 00:02:32,710
מצגות בסעיף.

49
00:02:32,710 --> 00:02:35,040
יש גם טיפים וטריקים להתמודדות
עם פונקציות, ויש

50
00:02:35,040 --> 00:02:37,290
בעיות בפועל שתעזורנה
אתה עובד עם פונקציות.

51
00:02:37,290 --> 00:02:41,500
גם אנחנו נותנים לך קישורים לקצרים על
פונקציות ופעמים שפונקציות

52
00:02:41,500 --> 00:02:42,750
יש לבוא בהרצאה.

53
00:02:42,750 --> 00:02:46,550
אז study.cs50.net, מותג חדש
שנה, משאב נפלא.

54
00:02:46,550 --> 00:02:52,180
>> בשלב הבא, יש לי אדם, שהוא המדריך
הפקודה שאתה יכול לרוץ ב

55
00:02:52,180 --> 00:02:52,770
שורת הפקודה.

56
00:02:52,770 --> 00:02:57,880
אז אם יש לך שאלות כלשהן על
הפקודה, למשל, rand, שבו אנו

57
00:02:57,880 --> 00:03:00,900
נתקל בשבוע שעבר בסעיף
ויש לך סיכוי נתקל ב

58
00:03:00,900 --> 00:03:05,380
הבעיה שלך להגדיר כאשר עובר
ליצור קוד, אבל אם תקליד אדם

59
00:03:05,380 --> 00:03:09,980
rand, תקבל את הדף ש
מספר לך על כל rand.

60
00:03:09,980 --> 00:03:14,040
זה נותן לך את מה שנדרש,
פרמטרים שנדרש, כמו גם תשואה

61
00:03:14,040 --> 00:03:16,530
סוג ותיאור קצר
של פונקציה.

62
00:03:16,530 --> 00:03:17,500
>> אז לבדוק rand.

63
00:03:17,500 --> 00:03:22,270
זה יכול להיות קצת מלל ומבלבל,
אז לפעמים אני מוצא את זה

64
00:03:22,270 --> 00:03:26,150
פשוט Googling את מה שאני רוצה לדעת הוא
הדרך הטובה ביותר למצוא את התשובה.

65
00:03:26,150 --> 00:03:27,940
אז להתאמן עם גוגל.

66
00:03:27,940 --> 00:03:28,600
קבל טוב בגוגל.

67
00:03:28,600 --> 00:03:30,600
זה יהפוך לחבר הכי טוב שלך.

68
00:03:30,600 --> 00:03:34,300
>> כמו גם גוגל, אם אתה לא יכול למצוא אותו
בגוגל, cs50.net/discuss, זה

69
00:03:34,300 --> 00:03:35,550
הדיון בפורום.

70
00:03:35,550 --> 00:03:39,390
רוב הסיכויים שאם יש לך שאלה, אחד
700 + בני גילך יש גם ש

71
00:03:39,390 --> 00:03:42,110
שאלה ואולי ביקשתי
זה כבר בלדון

72
00:03:42,110 --> 00:03:43,540
פורומים ויש לו תשובה.

73
00:03:43,540 --> 00:03:48,130
אז אם יש לכם שאלה או משותפת
יש לך שאלה שאתה חושב

74
00:03:48,130 --> 00:03:52,300
אולי אנשים אחרים אולי נתקל,
לבדוק את cs50.net/discuss.

75
00:03:52,300 --> 00:03:55,450
>> לבסוף, שני האחרונים, אם אתה רוצה
לדבר עם בן, משרד אמיתי אנושי

76
00:03:55,450 --> 00:03:57,770
שעות בימים שני עד שישי.

77
00:03:57,770 --> 00:04:00,850
יש גם שעתי עבודה באינטרנט
לתלמידי ארכה.

78
00:04:00,850 --> 00:04:04,370
ואחרון אך לא פחות חשוב,
לי, סימן קריאה.

79
00:04:04,370 --> 00:04:05,960
לכולכם יש את פרטי הקשר שלי.

80
00:04:05,960 --> 00:04:11,940
אם אתה צריך משהו, בבקשה לא
תהסס לפנות אלי.

81
00:04:11,940 --> 00:04:14,020
תמיד מרגיש חופשי לעשות זאת.

82
00:04:14,020 --> 00:04:17,490
מעטים מאוד שהוספתם אותי בGchat,
כך שהיה מאכזב,

83
00:04:17,490 --> 00:04:20,410
אבל אני מקווה שאשנה בין
זה והסעיף הבא.

84
00:04:20,410 --> 00:04:22,105
כל שאלות עד כה על המשאבים?

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

86
00:04:25,670 --> 00:04:27,450
גדול.

87
00:04:27,450 --> 00:04:34,280
>> לבסוף, תקע נוסף עבור
משוב, sayat.me/cs50.

88
00:04:34,280 --> 00:04:37,050
אתה יכול לתת לי משוב בעילום שם
על איך שאני עושה.

89
00:04:37,050 --> 00:04:38,320
זה היה באמת מועיל בשבוע שעבר.

90
00:04:38,320 --> 00:04:41,890
יש לי כמה הערות ממך חבר 'ה
מייד אחרי סעיף, בתוספת מ

91
00:04:41,890 --> 00:04:44,750
תלמידים אחרים שצפו בו
במהלך השבוע, וזה

92
00:04:44,750 --> 00:04:46,830
היה עוזר לנו מאוד.

93
00:04:46,830 --> 00:04:50,250
אני הולך לנסות ולהגביל את השימוש שלי
המילה "מתוקה", אבל אני אראה לי

94
00:04:50,250 --> 00:04:52,410
התלהבות והתרגשות
בדרכים אחרות.

95
00:04:52,410 --> 00:04:56,550
אבל היו נוסף אחרים
פידבקים מהותיים,

96
00:04:56,550 --> 00:04:57,600
שני פלוסים ודלתא.

97
00:04:57,600 --> 00:05:00,480
אז בבקשה, אני נותן לך החבר 'ה משוב
על קבוצות הבעיה שלך.

98
00:05:00,480 --> 00:05:01,790
אתה מוזמן לתת לי משוב
בהוראה שלי.

99
00:05:01,790 --> 00:05:04,010
אני כאן בשבילכם.

100
00:05:04,010 --> 00:05:05,270
>> גדול.

101
00:05:05,270 --> 00:05:07,020
זה כל מה שיש לי בשביל
החלק הראשון.

102
00:05:07,020 --> 00:05:08,565
האם יש למישהו כל
שאלות עד כה?

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

104
00:05:12,370 --> 00:05:14,640
ויש לי פתק עבור
מרכז השליטה והבקרה.

105
00:05:14,640 --> 00:05:21,200
הסטודנטים הארכה לא שלחו הודעה לי
אומר שהם לא מקבלים שום אודיו,

106
00:05:21,200 --> 00:05:23,870
אבל זה מחוץ לכחיי לתקן.

107
00:05:23,870 --> 00:05:25,280
כך אני מקווה, שמקבל
נפתר תוך זמן קצר.

108
00:05:25,280 --> 00:05:28,850
אם אתה צופה באינטרנט, היי,
אבל אתה לא יכול לשמוע אותי.

109
00:05:28,850 --> 00:05:33,860
>> אז קודם כל, אנחנו הולכים
לעבור GDB.

110
00:05:33,860 --> 00:05:37,100
GDB, כפי שרמזתי בקודם לכן,
הוא כלי ניפוי שגיאות

111
00:05:37,100 --> 00:05:39,040
הרבה יותר טוב מאשר printf.

112
00:05:39,040 --> 00:05:44,700
אז כדי להתחיל לעבוד עם GDB, חבר 'ה, אם
אתה רוצה לפתוח את המכשיר שלך

113
00:05:44,700 --> 00:05:49,070
ולקחת את הקובץ שאני אליך
קודם לכן - בקובץ זה יהיה גם

114
00:05:49,070 --> 00:05:51,940
זמין באינטרנט בקצת -

115
00:05:51,940 --> 00:05:55,700
ולהפעיל GDB. / את השם של הקובץ.

116
00:05:55,700 --> 00:05:58,580
ראשית, כמובן, אתה צריך לקמפל
להגיש בגלל GDB עובד על רק

117
00:05:58,580 --> 00:05:59,890
קבצי הפעלה.

118
00:05:59,890 --> 00:06:02,300
>> אבל אם אי פעם אתה רוצה להתחיל
GDB, הדבר הראשון שאתה עושה,

119
00:06:02,300 --> 00:06:04,550
אתה מפעיל GDB. / קיסר.

120
00:06:04,550 --> 00:06:08,340
אז זה השם של התכנית שאנחנו
הולך עם זה עכשיו.

121
00:06:08,340 --> 00:06:12,810
אז אני הולך לכתוב להפוך את הקיסר, אשר
ייתן לי קובץ הפעלה

122
00:06:12,810 --> 00:06:14,100
כאן מודגש בירוק.

123
00:06:14,100 --> 00:06:19,250
ולאחר מכן אני הולך לרוץ GDB. / סזאר.

124
00:06:19,250 --> 00:06:19,810
>> והנה לך.

125
00:06:19,810 --> 00:06:24,540
אתה רואה שיש לנו חלק מטקסט אומר לי
על הגרסה של GDB, נותנת לי

126
00:06:24,540 --> 00:06:27,570
כמה מידע על אחריות, ואז אנחנו
יש הפקודה התמ"ג, שנראית מין

127
00:06:27,570 --> 00:06:29,350
כמו הפקודה שורת הפקודה שלנו,
אבל אתה רואה שזה פתוח

128
00:06:29,350 --> 00:06:32,510
פארן, GDB, paren קרוב.

129
00:06:32,510 --> 00:06:36,520
לפני שנמשיך וניפוי שגיאות בקובץ זה
שנשלחתי לכולכם, בואו נסתכל על

130
00:06:36,520 --> 00:06:40,220
כמה פקודות שימושיות כל כך יש לנו תחושה
של מה שאנחנו הולכים לכסות.

131
00:06:40,220 --> 00:06:45,060
>> פקודות אלה מופיעות כאן ב
הסדר שבו אני בדרך כלל להשתמש בם.

132
00:06:45,060 --> 00:06:50,230
אז אני מתחיל את התכנית שלי על ידי הפעלה
GBD. / שמה של התכנית,

133
00:06:50,230 --> 00:06:51,360
במקרה זה, קיסר.

134
00:06:51,360 --> 00:06:57,430
ואז הדבר הראשון שאני עושה 99.9%
של זמן הפסקת הסוג מתכוונת.

135
00:06:57,430 --> 00:06:59,070
שקובע נקודת הפסקה בראשית.

136
00:06:59,070 --> 00:07:03,260
בעיקרו של דבר, מה שאתה עושה שם
היא התכנית הוא הולכת לעצור ב

137
00:07:03,260 --> 00:07:06,100
עיקרי, כך שאתה יכול להתחיל לבחון אותו בתור
על ידי קו, ולא פועל בכל

138
00:07:06,100 --> 00:07:07,040
הדרך.

139
00:07:07,040 --> 00:07:09,730
אתה יכול לשבור בנקודות שונות ב
הקוד שלך, אבל עיקרי הוא בדרך כלל

140
00:07:09,730 --> 00:07:11,870
מקום טוב להתחיל בו.

141
00:07:11,870 --> 00:07:14,840
>> הפקודה הבאה אני רץ היא ארוך.

142
00:07:14,840 --> 00:07:17,400
שמתחיל הריצה התכנית, ו
אם אתה צריך להיכנס לשורת הפקודה

143
00:07:17,400 --> 00:07:19,090
טיעונים, אתה מפעיל אותו פיקוד ש.

144
00:07:19,090 --> 00:07:20,500
לרוץ עם הטיעונים.

145
00:07:20,500 --> 00:07:25,000
אז מאז אנחנו הולכים על גרסה
של C, המהווה את תכניתכם

146
00:07:25,000 --> 00:07:26,160
כתבתי לpset שתי -

147
00:07:26,160 --> 00:07:29,880
זה, כמובן יש לו, כמה באגים
בזה שאני מקווה שנמצא -

148
00:07:29,880 --> 00:07:32,810
אנחנו הולכים לרוץ ריצה עם כמה פקודת
טיעוני שורה כי קיסר,

149
00:07:32,810 --> 00:07:34,860
כמו שאתם יודעים לכל הבעיה
להגדיר מפרט, לוקח קצת

150
00:07:34,860 --> 00:07:36,380
טיעוני שורת הפקודה.

151
00:07:36,380 --> 00:07:40,000
>> הזוג הבא של פקודות, הבא
אחד נקרא למעשה הבא.

152
00:07:40,000 --> 00:07:42,470
אחד שלוקח קו אתה בקו
באמצעות התכנית שלך.

153
00:07:42,470 --> 00:07:45,800
אז להכות n אז על Enter לוקח אותך
לשורה הבאה, ביצוע

154
00:07:45,800 --> 00:07:46,880
השורה הקודמת.

155
00:07:46,880 --> 00:07:49,440
שלב לוקח אותך לא רק כדי
השורה הבאה, אבל זה

156
00:07:49,440 --> 00:07:51,070
לוקח אותך פונקציות בפנים.

157
00:07:51,070 --> 00:07:54,310
אז אם יש לך כתב פונקציה ב
הקוד או שלך, אם אתה רוצה לחקור

158
00:07:54,310 --> 00:07:57,820
ל i, למשל, אתה יכול להכות ים, ו
ולא הולכים לשורה הבאה של

159
00:07:57,820 --> 00:08:02,390
את הקובץ שאתם עוברים תקין
עכשיו, אתה בעצם להיכנס

160
00:08:02,390 --> 00:08:04,670
פונקציה זו ולראות את הקוד שלה.

161
00:08:04,670 --> 00:08:12,300
>> רשימה מראה לך, במאוד ידידותית למשתמש
פורמט, 10 או כך הקווים סביב

162
00:08:12,300 --> 00:08:14,940
שבו אתה נמצא כעת בקוד שלך
כך שאתה ממש יכול לראות את הקובץ

163
00:08:14,940 --> 00:08:17,810
ולא שיש להחליף בחזרה ו
שוב בין תצוגות שונות.

164
00:08:17,810 --> 00:08:21,890
הדפסה היא כמו printf,
כפי ששמתי מרמז.

165
00:08:21,890 --> 00:08:24,020
זה מראה לך מה שווים משתנה.

166
00:08:24,020 --> 00:08:25,870
>> המקומיים מידע באמת מועילים.

167
00:08:25,870 --> 00:08:27,740
זוהי גרסה מיוחדת של הדפסה.

168
00:08:27,740 --> 00:08:31,770
המקומיים מידע מראה לך את כל המקומי
משתנים, מדפיס את כולם בשבילך

169
00:08:31,770 --> 00:08:33,380
זמינים כעת.

170
00:08:33,380 --> 00:08:36,360
אז אני בדרך כלל, ולא אצטרך
להדפיס את המשתנים ארבעה שאני

171
00:08:36,360 --> 00:08:39,929
סקרן לגבי אם אני ללולאה, עבור
למשל, אני פשוט לכתוב המקומיים מידע,

172
00:08:39,929 --> 00:08:43,470
וזה אראה לי את מה שאני הדלפק שלי
שווה, כמו גם את המערך שאני

173
00:08:43,470 --> 00:08:45,130
עובד על שווים.

174
00:08:45,130 --> 00:08:47,530
>> לבסוף, להמשיך.

175
00:08:47,530 --> 00:08:49,300
הקלדת הפסקה עוצרת אותך
בנקודת ההפסקה.

176
00:08:49,300 --> 00:08:51,380
אתה יכול ללכת דרך קו על ידי
קו עם הבא וצעד.

177
00:08:51,380 --> 00:08:55,640
המשך מפעילה את התכנית לבאה שלך
לשבור נקודה או עד להשלמה אם

178
00:08:55,640 --> 00:08:57,180
אין יותר נקודות הפסקה.

179
00:08:57,180 --> 00:09:00,060
השבת מסירה נקודות הפסקה אם אתה
החליט ההפסקה במרכזית הייתה

180
00:09:00,060 --> 00:09:01,890
בלתי הולם, אתה רוצה
להגדיר את זה במקום אחר.

181
00:09:01,890 --> 00:09:05,090
ולבסוף q, לפרוש, יוצא מGDB.

182
00:09:05,090 --> 00:09:10,784
>> אז תכנית זו,. / קיסר, אנחנו הולכים
להסתכל דרך עכשיו ואנחנו

183
00:09:10,784 --> 00:09:13,490
הולכים להשתמש GDB למצוא
באגים בתכנית זו.

184
00:09:13,490 --> 00:09:18,110
רצתי בתכנית זו קודם לכן עם
בדוק 50, ויש לי קמט אחד.

185
00:09:18,110 --> 00:09:22,310
כל מה שקיים, זה הידור, זה
עברתי הרבה בדיקות, אבל עבור

186
00:09:22,310 --> 00:09:27,950
משום מה, זה לא עבר חמישי
בדיקה, מפנה BARFOO, כל כמוסות, לתוך

187
00:09:27,950 --> 00:09:33,350
E-D-U-I-R-R, כל כמוסות,
באמצעות שלושה כמפתח.

188
00:09:33,350 --> 00:09:34,090
יש לי די קרוב.

189
00:09:34,090 --> 00:09:35,410
ירדתי על ידי אות אחת.

190
00:09:35,410 --> 00:09:37,340
אז יש איזו טעות קטנה לכאן.

191
00:09:37,340 --> 00:09:38,070
אני כבר הסתכלתי דרך הקוד שלי.

192
00:09:38,070 --> 00:09:38,850
אני לא יכול להבין את זה.

193
00:09:38,850 --> 00:09:41,740
יש לקוות, שאתם יכולים לעזור לי
להבין מה הוא הבאג הזה.

194
00:09:41,740 --> 00:09:44,610
>> אז זה הטעות אנחנו
מחפש.

195
00:09:44,610 --> 00:09:46,090
בואו נעבור לGDB.

196
00:09:46,090 --> 00:09:51,100
שוב, אני כבר להפעיל GDB. / קיסר,
אז עכשיו אנחנו בGDB.

197
00:09:51,100 --> 00:09:54,290
ומה הוא הראשון
דבר שאני צריך לעשות?

198
00:09:54,290 --> 00:09:56,680
אני פשוט נכנסתי GDB.

199
00:09:56,680 --> 00:10:00,316
מישהו ייתן לי טוב
הפקודה להיכנס.

200
00:10:00,316 --> 00:10:01,140
>> סטודנט: לשבור ראשי.

201
00:10:01,140 --> 00:10:01,800
>> ג'ייסון הירשהורן: לשבור ראשי.

202
00:10:01,800 --> 00:10:02,900
פנטסטי.

203
00:10:02,900 --> 00:10:03,560
בואו נקליד שבי

204
00:10:03,560 --> 00:10:06,390
אתם יכולים לצפות כאן למעלה או בצעו
יחד במחשבים שלך.

205
00:10:06,390 --> 00:10:09,410
לשבור ראשי, ותראה
נקודת פריצה נקבעה ל -

206
00:10:09,410 --> 00:10:12,340
זה נותן לי קצת מוזר כתובת זיכרון,
וזה גם נותן לי את מספר הקו.

207
00:10:12,340 --> 00:10:15,310
אם הייתי מסתכל אחורה על קובץ זה,
אני מבין עיקרי ש

208
00:10:15,310 --> 00:10:17,700
קרה על קו 21.

209
00:10:17,700 --> 00:10:18,950
מה אני צריך לרוץ הלאה?

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

211
00:10:22,970 --> 00:10:25,060
האם התכנית שלי פועלת?

212
00:10:25,060 --> 00:10:25,650
לא.

213
00:10:25,650 --> 00:10:27,175
אז מה אני צריך לרוץ הלאה?

214
00:10:27,175 --> 00:10:27,520
>> תלמיד: הפעל.

215
00:10:27,520 --> 00:10:28,050
>> ג'ייסון הירשהורן: הפעל.

216
00:10:28,050 --> 00:10:30,760
אני צריך רק לרוץ לרוץ, או צריך
אני מוסיף עוד כמה דברים ב?

217
00:10:30,760 --> 00:10:31,960
>> תלמיד: הפעל עם הוויכוח.

218
00:10:31,960 --> 00:10:33,320
>> ג'ייסון הירשהורן: הפעל עם
פקודת הטיעונים.

219
00:10:33,320 --> 00:10:36,420
ומאז אני באגים מאוד ספציפי
מקרה, אני צריך להיכנס כי

220
00:10:36,420 --> 00:10:37,120
ויכוח שורת הפקודה.

221
00:10:37,120 --> 00:10:42,290
אז אל אני ארוץ שלוש, שהוא, שוב,
התפוקה שקיבלתי מעזיבה 50.

222
00:10:42,290 --> 00:10:44,240
הפעלת תכנית.

223
00:10:44,240 --> 00:10:45,420
אנחנו עוברים שתי שורות.

224
00:10:45,420 --> 00:10:47,700
כעת יראו שאנחנו על קו 21.

225
00:10:47,700 --> 00:10:49,200
איך אני יודע שאנחנו על קו 21?

226
00:10:49,200 --> 00:10:52,170
כי אם אתה מסתכל לצד השמאל
של חלון המסוף שלי, יש

227
00:10:52,170 --> 00:10:53,120
זה אומר שורה 21.

228
00:10:53,120 --> 00:10:57,010
וזה נותן לי, בעצם,
קוד שהוא בשורה 21.

229
00:10:57,010 --> 00:10:58,440
אז אני misspoke קודם לכן.

230
00:10:58,440 --> 00:10:59,770
העיקרי הוא לא ממש בשורה 21.

231
00:10:59,770 --> 00:11:02,000
העיקרי הוא כמה שורות מעל 21.

232
00:11:02,000 --> 00:11:04,300
אבל בשורה 21, זה
לאן אנחנו שבירה.

233
00:11:04,300 --> 00:11:06,280
קו זה של קוד יש
עדיין לא בוצע.

234
00:11:06,280 --> 00:11:06,890
זה חשוב.

235
00:11:06,890 --> 00:11:09,120
השורה שאתה רואה יש לא
בוצע עדיין.

236
00:11:09,120 --> 00:11:12,650
זו השורה הבאה של קוד
אתה עומד לבצע.

237
00:11:12,650 --> 00:11:15,860
>> אז השורה הבאה, כפי שאתם
בטח מכיר, היא זו

238
00:11:15,860 --> 00:11:20,070
מצב בדיקה כדי לראות אם יש לי
נכנס טיעון שורת הפקודה.

239
00:11:20,070 --> 00:11:22,140
וכדי שאני, מה הוא שני
חלק מזה עושה?

240
00:11:22,140 --> 00:11:23,457
מהו ל i?

241
00:11:23,457 --> 00:11:24,950
>> סטודנט: שינוי אותו למספר שלם.

242
00:11:24,950 --> 00:11:25,450
>> ג'ייסון הירשהורן: סליחה?

243
00:11:25,450 --> 00:11:27,400
>> תלמיד: זה משתנה
טיעון למספר שלם.

244
00:11:27,400 --> 00:11:30,890
>> ג'ייסון הירשהורן: אז כדי שאני משנה ARG
v1 ממחרוזת למספר שלם.

245
00:11:30,890 --> 00:11:32,140
ואז מה זה בודק?

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

247
00:11:35,414 --> 00:11:37,112
>> תלמיד: אם יש שני
ויכוח שורת הפקודה, בצד

248
00:11:37,112 --> 00:11:38,100
מהפעלת התכנית.

249
00:11:38,100 --> 00:11:39,460
>> ג'ייסון הירשהורן: ומה
המחצית השנייה של

250
00:11:39,460 --> 00:11:41,220
ביטוי בוליאני בדיקה?

251
00:11:41,220 --> 00:11:42,540
חלק זה לכאן, כדי שאני?

252
00:11:42,540 --> 00:11:44,080
>> תלמיד: אם זה שלילי.

253
00:11:44,080 --> 00:11:45,380
>> ג'ייסון הירשהורן: הפיכת מה שבטוח?

254
00:11:45,380 --> 00:11:47,120
>> סטודנט: ביצוע זה בטוח
זהו, למעשה, חיובי.

255
00:11:47,120 --> 00:11:47,650
>> ג'ייסון הירשהורן: בדיוק.

256
00:11:47,650 --> 00:11:50,600
זו בדיקה כדי לראות אם זה
שלילי, ואם הוא שלילי, אני

257
00:11:50,600 --> 00:11:53,220
יש לי תחושת כוח השורה הבאה
להיות לי לצעוק על המשתמש.

258
00:11:53,220 --> 00:11:55,930
אז בואו פגעו סוף לבצע את הקו הזה.

259
00:11:55,930 --> 00:11:59,925
אנחנו לא רואים את הקו הזה שאתם
אולי ציפיתי לראות צועקים על

260
00:11:59,925 --> 00:12:03,030
משתמש ולאחר מכן חזר, כי
הקו הזה לא בצע.

261
00:12:03,030 --> 00:12:03,840
אני נכנסתי 3.

262
00:12:03,840 --> 00:12:06,860
אז אני לא, למעשה, להיכנס לשתי הפקודה
טיעוני קו, ו -3 הוא

263
00:12:06,860 --> 00:12:07,610
גדול מאפס.

264
00:12:07,610 --> 00:12:09,950
אז שראינו כי קו, אנחנו להורג,
אבל אנחנו לא לדרוך

265
00:12:09,950 --> 00:12:11,300
בתוך אם המצב.

266
00:12:11,300 --> 00:12:17,060
>> אז עכשיו, הבא, אני רואה שאני הגדרה
מפתח int שווה ל i ARG v1.

267
00:12:17,060 --> 00:12:18,840
אז זה יצירת מפתח משתנה.

268
00:12:18,840 --> 00:12:22,450
אז אם אני מדפיס את מפתח עכשיו, כי
המאפשר לך לראות את

269
00:12:22,450 --> 00:12:26,040
ערך בתוך משתנה,
מפתח שווה 47.

270
00:12:26,040 --> 00:12:28,810
זה מוזר, אבל כמובן,
זה בגלל שאין לי

271
00:12:28,810 --> 00:12:30,490
להורג קו שעדיין.

272
00:12:30,490 --> 00:12:35,880
אז עכשיו אם אני מכה n, לבצע את הקו,
ולעשות מפתח הדפסה, המפתח יהיה שווה 3,

273
00:12:35,880 --> 00:12:37,740
וזה מה שאנחנו מצפים שזה שווה.

274
00:12:37,740 --> 00:12:41,170
>> אז שוב, בGDB, השורה אתה
רואה שלא בוצע עדיין.

275
00:12:41,170 --> 00:12:44,850
אתה צריך להכות n או ים או מספר
של פקודות אחרות למעשה

276
00:12:44,850 --> 00:12:46,610
ביצוע של קו זה.

277
00:12:46,610 --> 00:12:47,380
מפתח הדפסה.

278
00:12:47,380 --> 00:12:48,280
מפתח של שעת 3.

279
00:12:48,280 --> 00:12:49,750
עד כה, כל כך טוב.

280
00:12:49,750 --> 00:12:51,000
מחרוזת היא טקסט רגיל.

281
00:12:51,000 --> 00:12:52,270
בואו לבצע קו זה.

282
00:12:52,270 --> 00:12:53,970
אני מקבל מחרוזת מהמשתמש.

283
00:12:53,970 --> 00:12:58,690
>> בואו לראות בעזיבה שלי 50, אני
הכנס BARFOO כל כמוסות, ולכן

284
00:12:58,690 --> 00:13:01,330
זה מה שאני נכנסים.

285
00:13:01,330 --> 00:13:07,300
אם אני עכשיו להדפיס טקסט רגיל.

286
00:13:07,300 --> 00:13:08,610
אתה תראה שזה שווה מחרוזת.

287
00:13:08,610 --> 00:13:11,100
זה נותן לי קצת מוזר הקסדצימלי אחר
מספר, אך היא עושה ב

288
00:13:11,100 --> 00:13:13,620
למעשה אומרים שהמחרוזת שלי היא BARFOO.

289
00:13:13,620 --> 00:13:19,308
אם אני רוצה לראות מה מפתח שווה ב
שלב זה, איך אני יכול לבדוק את המפתח?

290
00:13:19,308 --> 00:13:20,710
>> תלמיד: מפתח הדפסה.

291
00:13:20,710 --> 00:13:22,010
>> ג'ייסון הירשהורן: מפתח הדפסה, בדיוק.

292
00:13:22,010 --> 00:13:23,260
ולמעשה, יש קיצור.

293
00:13:23,260 --> 00:13:25,910
אם נמאס לך להקליד הדפסה,
אתה יכול פשוט להקליד p.

294
00:13:25,910 --> 00:13:28,340
אז מקש p עושה את אותו דבר בדיוק.

295
00:13:28,340 --> 00:13:29,730
ושוב, אני רואה את זה שווה 3.

296
00:13:29,730 --> 00:13:34,760
>> אם אני רוצה לברר מה הן מפתח
וBARFOO שווה באותו הזמן

297
00:13:34,760 --> 00:13:37,215
אבל היה עייף של הקלדה כולי
אחד מתוך בנפרד, אני

298
00:13:37,215 --> 00:13:38,590
יכול להקליד המקומיים מידע.

299
00:13:38,590 --> 00:13:41,170
זה נותן לי שווים מפתח 3.

300
00:13:41,170 --> 00:13:42,500
טקסט רגיל שווה BARFOO.

301
00:13:42,500 --> 00:13:45,265
זה גם נותן לי שני דברים מוזרים האלה
בחלק העליון, משתנה זה אני ו

302
00:13:45,265 --> 00:13:46,590
n משתנה זה.

303
00:13:46,590 --> 00:13:48,460
>> אלה למעשה קיימים
בתכנית הראשית שלי.

304
00:13:48,460 --> 00:13:51,280
יש לנו לא נתקלתי בם עדיין,
אבל כתצוגה מקדימה, אלה

305
00:13:51,280 --> 00:13:52,880
קיימת בי ללולאה.

306
00:13:52,880 --> 00:13:55,360
אז עכשיו, שהם שווים קצת מוזרים
מספרים, כי הם לא היו

307
00:13:55,360 --> 00:13:58,300
אותחל עדיין, אבל הם עדיין קיימים
לזכרו, ולכן הם פשוט להגדיר

308
00:13:58,300 --> 00:14:00,220
כמה ערך זבל.

309
00:14:00,220 --> 00:14:02,890
אבל אנחנו רואים את המפתח במישור
טקסט ממש שם.

310
00:14:02,890 --> 00:14:06,390
>> אז אני הולך לבצע את הקו הזה,
שורה 34, ללולאה.

311
00:14:06,390 --> 00:14:08,220
אנחנו הולכים לקפוץ לתוך
ללולאה על ידי להכות n.

312
00:14:08,220 --> 00:14:10,050
ואנחנו בתוך הלולאה for.

313
00:14:10,050 --> 00:14:11,360
אנחנו בבדיקה הראשונה שלנו.

314
00:14:11,360 --> 00:14:14,300
ושוב, אלה צריכים סוג של נראים
מוכר לך, כי זה היה

315
00:14:14,300 --> 00:14:18,080
תכנית הקיסר שנכתבה, אבל
שוב, יש לו איזה באג.

316
00:14:18,080 --> 00:14:21,940
>> ועכשיו אם אני עושה את המקומיים מידע, בגלל שאני
בתוך כך ללולאה, תוכל לראות

317
00:14:21,940 --> 00:14:23,900
כי אני שווה אפס, כפי שאנו מצפים.

318
00:14:23,900 --> 00:14:26,820
זה מה שאנחנו מגדירים את זה ואותחלנו
זה ללולאה.

319
00:14:26,820 --> 00:14:27,560
n שווה ל -6.

320
00:14:27,560 --> 00:14:30,700
זה גם הגיוני, כי אנו קובעים
זה לstrlen של טקסט רגיל.

321
00:14:30,700 --> 00:14:34,270
אז אני רוצה לעשות את המקומיים מידע או הדפסה
למשתנה לעתים קרובות כדי לוודא ש

322
00:14:34,270 --> 00:14:36,370
הכל תמיד מה
אני מצפה שזה שווה.

323
00:14:36,370 --> 00:14:39,800
במקרה זה, כל מה שהוא
מה שאני מצפה שזה שווה.

324
00:14:39,800 --> 00:14:41,850
>> אז בואו נתחיל לנוע דרך
זה ללולאה.

325
00:14:41,850 --> 00:14:45,715
השורה אני בהיא קו 36, אם רגיל
הוא אני טקסט גדול וממישור

326
00:14:45,715 --> 00:14:48,540
אני טקסט הוא פחות או שווה ל z.

327
00:14:48,540 --> 00:14:51,880
אני יודע שהבעיה שלי היא לא עם הראשון שלי
מכתב, זה באות השנייה.

328
00:14:51,880 --> 00:14:56,290
אם אנחנו מסתכלים אחורה על עזיבה
50, לינה הולכת לE בסדר.

329
00:14:56,290 --> 00:14:59,010
אני לוקח ומשאיר אותו כמו
, לא משנה אותו לד אז

330
00:14:59,010 --> 00:15:00,200
משהו לא בסדר עם
המכתב השני.

331
00:15:00,200 --> 00:15:01,640
אז אני הולך לעבור
יש בשנייה.

332
00:15:01,640 --> 00:15:06,030
>> אבל אם אני לא רוצה לבדוק את מה שרגיל
טקסט שהשתוויתי בזה בפרט

333
00:15:06,030 --> 00:15:07,760
מקרה, אני חושב שזה צריך להיות מה?

334
00:15:07,760 --> 00:15:10,980
מה צריך טקסט רגיל אני שווה בזה
הסיבוב ראשון בלולאה for?

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

336
00:15:14,046 --> 00:15:15,110
>> סטודנט: אפס?

337
00:15:15,110 --> 00:15:16,510
>> ג'ייסון הירשהורן: טקסט רגיל שלי?

338
00:15:16,510 --> 00:15:21,180
כך זה צריך להיות ב 'הוני, כמובן,
שווה אפס, אבל טקסט רגיל

339
00:15:21,180 --> 00:15:25,600
אפס סוגר סגור סוגריים שווים B
בגלל מיתרים, כפי שראינו בשבוע שעבר,

340
00:15:25,600 --> 00:15:28,650
הם מערך, ולכן אנחנו מקבלים את
תו ראשון מזה.

341
00:15:28,650 --> 00:15:34,960
אז שוב, אם אני הדפסתי טקסט רגיל של
אני, אני, למעשה, לקבל את התו

342
00:15:34,960 --> 00:15:36,560
ב 'וזה מסודר, נכון?

343
00:15:36,560 --> 00:15:40,380
בעצם אין לי I. טקסט רגיל
זה לא אחד מהמשתנים שנקבעתי

344
00:15:40,380 --> 00:15:42,950
או אותחל, אבל אתה יכול להדפיס
מתוך שורה של דברים שלמות

345
00:15:42,950 --> 00:15:45,640
אם אתה רוצה.

346
00:15:45,640 --> 00:15:47,340
>> אבל בואו נעבור דרכו.

347
00:15:47,340 --> 00:15:50,050
אם אני טקסט רגיל הוא גדול יותר ומ
אני טקסט רגיל הוא פחות או שווה ל

348
00:15:50,050 --> 00:15:53,290
Z, כי ברור הוא נכון, כי יש לנו
ב הון אני הולך לרוץ

349
00:15:53,290 --> 00:15:54,230
כמה פיקוד עליו.

350
00:15:54,230 --> 00:15:58,530
ראינו במתמטיקה כי בשבוע שעבר, אז אנחנו
לקחת את זה כמובן מאליו שזה עובד

351
00:15:58,530 --> 00:16:00,900
נכון בהתאם להגעת 50.

352
00:16:00,900 --> 00:16:03,720
>> הסוגריים מסולסלים האלה, הראשון
הראיתי שאני יוצא אם

353
00:16:03,720 --> 00:16:07,030
מצב, השני הראה
שאני יוצא ללולאה.

354
00:16:07,030 --> 00:16:10,400
ואז עכשיו כשאני מכה בשלב הבא, נוכל לראות
אנחנו שוב ללולאה שוב.

355
00:16:10,400 --> 00:16:11,970
אנחנו עוברים
ללולאה שוב.

356
00:16:11,970 --> 00:16:18,110
בואו למעשה להיכנס לשני
איטרציה של לולאה והסוג

357
00:16:18,110 --> 00:16:20,520
המקומיים מידע.

358
00:16:20,520 --> 00:16:22,190
>> אז אנחנו באיטרציה השנייה
של ללולאה שלנו.

359
00:16:22,190 --> 00:16:24,530
אני שווה 1, שבו אנו מצפים.

360
00:16:24,530 --> 00:16:26,650
N שווה 6, שבו אנו מצפים.

361
00:16:26,650 --> 00:16:28,810
מפתח שווה 3, שבו אנו מצפים.

362
00:16:28,810 --> 00:16:32,625
וטקסט רגיל, תראה, שווה
EARFOO עכשיו, לא BARFOO יותר, כי

363
00:16:32,625 --> 00:16:37,930
באיטרציה הקודמת שלנו, ב 'היה
השתנו להון E. אז אנחנו עומדים

364
00:16:37,930 --> 00:16:40,040
להיתקל בבעיה, אז זה
מקום שבו אנחנו הולכים

365
00:16:40,040 --> 00:16:41,130
לצלול לתוך איתור באגים.

366
00:16:41,130 --> 00:16:43,365
אבל האם למישהו יש שאלות
על מה שעשינו עד כה?

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

368
00:16:46,770 --> 00:16:47,910
פנטסטי.

369
00:16:47,910 --> 00:16:52,710
>> אז אנחנו עומדים לבצע את זה אם
מצב, סוגר טקסט רגיל סגרתי

370
00:16:52,710 --> 00:16:57,500
סוגר גדול יותר ואני טקסט רגיל
קטן או שווה לז' אבל לפני

371
00:16:57,500 --> 00:17:00,450
אני נכנסתי לזה, כי זה המקום שבי
אני יודע שהטעות שלי היא, אני רוצה לציין

372
00:17:00,450 --> 00:17:06,859
מתוך טקסט רגיל של I. אז
בואו נשים את הדפסה.

373
00:17:06,859 --> 00:17:12,020
הוא עושה שווה את הדמות, כך ש
נראה עד כה, הכל טוב ויפה.

374
00:17:12,020 --> 00:17:14,740
>> אז אני מצפה את הקו הזה להיגיון שלי,
קו זה צריך להיות אמיתי.

375
00:17:14,740 --> 00:17:16,099
זה באות גדולה.

376
00:17:16,099 --> 00:17:20,599
אבל אם אני מכה n, אנחנו מבינים שזה
קו, למעשה, לא בצע.

377
00:17:20,599 --> 00:17:22,609
קפצתי לאחר אם.

378
00:17:22,609 --> 00:17:25,460
למה זה קרה?

379
00:17:25,460 --> 00:17:27,480
>> תלמיד: כי יש לך את המצב שלך
של טקסט רגיל הוא גדול יותר

380
00:17:27,480 --> 00:17:29,130
מ, לא שווה או גדול מ.

381
00:17:29,130 --> 00:17:32,260
>> ג'ייסון הירשהורן: אז היה לי הטקסט רגיל שלי
אני עולה, לא יותר

382
00:17:32,260 --> 00:17:32,850
או שווה ל.

383
00:17:32,850 --> 00:17:38,130
אז ברור, הבירה לא
תפעיל את זה אם מצב, ושעשינו

384
00:17:38,130 --> 00:17:40,520
לא להיכנס לזה, ושעשינו
לא לעשות את השינוי הדרוש.

385
00:17:40,520 --> 00:17:41,360
אז זהו, בעצם.

386
00:17:41,360 --> 00:17:42,920
אני הבנתי את הבאג שלי.

387
00:17:42,920 --> 00:17:46,775
אני יכול לחזור בקובץ המקור שלי,
לשנות את זה, ולעדכן אותו ו

388
00:17:46,775 --> 00:17:47,855
להפעיל בדקו 50 שוב.

389
00:17:47,855 --> 00:17:52,590
>> אבל נראה, רק לפדגוגיה של
למען, אם אני ממשיך הלאה.

390
00:17:52,590 --> 00:17:59,580
אחר אם לא גם לבצע, אבל
מה במקום שווה הוא הפקודה

391
00:17:59,580 --> 00:18:00,500
זה לא משנה.

392
00:18:00,500 --> 00:18:04,840
אז זה לא השתנה בכלל, ואם אני
להדפיס טקסט רגיל כאן, שנראה הולך

393
00:18:04,840 --> 00:18:08,250
דרך שללולאה לא, למעשה,
לשנות את זה תו שני בכלל.

394
00:18:08,250 --> 00:18:09,600
זה עדיין א הון

395
00:18:09,600 --> 00:18:12,690
>> אז שוב, אנו מדובג השגיאה שלנו.

396
00:18:12,690 --> 00:18:17,380
אנחנו הבנו שיש
קצת היגיון החסר.

397
00:18:17,380 --> 00:18:20,590
ואנחנו מדובג זה מבעוד מועד לפני
שמבצע בפועל את הקו,

398
00:18:20,590 --> 00:18:24,320
אבל היית שם לב שהיו לנו רק
להיט הבא ולקפוץ לכי אחר אם,

399
00:18:24,320 --> 00:18:26,710
זה אומר שאם מצב
לא היה נכון.

400
00:18:26,710 --> 00:18:29,550
לא, למעשה, לקבל
התוצאה שציפינו.

401
00:18:29,550 --> 00:18:33,240
אז היינו יכול היה מתבקש, היה
אנחנו לא היו כל כך נבונים, להסתכל על

402
00:18:33,240 --> 00:18:38,510
שאם מצב ולבדוק אם, למעשה,
המצב שלנו צריך להעריך ל

403
00:18:38,510 --> 00:18:41,150
אמיתי בהקשר הנוכחי.

404
00:18:41,150 --> 00:18:42,880
>> זה הכל לניפוי שגיאות בתכנית זו.

405
00:18:42,880 --> 00:18:45,340
האם יש למישהו שאלות?

406
00:18:45,340 --> 00:18:50,486
מה הפקודה שאני יכול להכות להפסיק GDB?

407
00:18:50,486 --> 00:18:53,900
ש: ואז אני תתבקש,
להפסיק בכל מקרה?

408
00:18:53,900 --> 00:18:54,390
כן או לא.

409
00:18:54,390 --> 00:18:58,440
אני אכה כן, ואני אצטרך להפסיק GDB.

410
00:18:58,440 --> 00:19:00,860
>> אז זה היה פריימר מהיר לGDB.

411
00:19:00,860 --> 00:19:03,430
למעשה, בתרחיש אמיתי,
עשיתי את זה בשעתי עבודה.

412
00:19:03,430 --> 00:19:06,710
אני GDBed התכנית הזה בדיוק, ב
שעתי עבודה עם תלמידים.

413
00:19:06,710 --> 00:19:12,410
ואם נחזור לפקודות שראינו
לפני כן, היינו עיקרי הפסקה, ראשון

414
00:19:12,410 --> 00:19:13,190
דבר שעשינו.

415
00:19:13,190 --> 00:19:16,060
נהגנו לרוץ עם טיעוני שורת הפקודה,
דבר שני שעשינו.

416
00:19:16,060 --> 00:19:18,520
אנו משמשים הבאים הרבה לעבור
שלנו דרך קווים.

417
00:19:18,520 --> 00:19:20,310
ושוב, גרסה הקצרה
של הבא הוא n.

418
00:19:20,310 --> 00:19:22,920
זה בסוגריים
באפור בשקופית.

419
00:19:22,920 --> 00:19:28,590
>> אנחנו לא השתמשנו בצעד, אבל אנחנו לא
בהכרח צריך למקרה זה.

420
00:19:28,590 --> 00:19:32,150
אבל אולי אנחנו משתמשים בו בקצת מאוחר יותר
היום אם אנחנו באגים, ל

421
00:19:32,150 --> 00:19:36,500
דוגמא, חיפוש בינארי כאשר בינארי
חיפוש נקרא בנפרד

422
00:19:36,500 --> 00:19:38,200
פונקציה אבל יש
שגיאה כלשהי עם זה.

423
00:19:38,200 --> 00:19:40,440
אנחנו הולכים לרוצים להיכנס
הקריאה לחיפוש בינארי ו

424
00:19:40,440 --> 00:19:41,840
למעשה באגים זה.

425
00:19:41,840 --> 00:19:45,130
רשימה אנחנו גם לא השתמשנו כי היו לנו
תחושה של הקוד שלנו טובה, אבל אם אני

426
00:19:45,130 --> 00:19:48,420
לא רוצה לקבל את תחושה של מה שאני קוד
היה בסביבה, אני יכול פשוט להשתמש ברשימה.

427
00:19:48,420 --> 00:19:50,310
>> הדפסה השתמשנו, מקומיים מידע השתמשנו.

428
00:19:50,310 --> 00:19:53,260
המשך אנחנו לא צריכים להשתמש בזה
מקרה, גם לא אנחנו צריכים להשתמש

429
00:19:53,260 --> 00:19:55,060
שימוש להשבית, אבל עשו להפסיק.

430
00:19:55,060 --> 00:19:57,850
שוב, 10 פקודות אלה,
לתרגל אותם.

431
00:19:57,850 --> 00:20:00,770
אם אתה מבין 10 פקודות אלה,
אתה צריך להיות מוגדר לאיתור באגים כל

432
00:20:00,770 --> 00:20:02,525
בעיה עם GDB.

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

434
00:20:05,230 --> 00:20:08,420
>> אז אנחנו עומדים לצאת, שוב, כדי
עיקרו של סעיף היום, הולכים על

435
00:20:08,420 --> 00:20:09,720
אלה מיון וחיפוש
אלגוריתמים.

436
00:20:09,720 --> 00:20:14,075
לפני שאנחנו עושים זאת, שוב, על כל שאלה,
הערות, חששות לGDB?

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

438
00:20:16,750 --> 00:20:20,960
אז הוא כולם הולכים להשתמש
GDB לא printf?

439
00:20:20,960 --> 00:20:24,550
אז כולם, למען לצמיתות,
כולם מהנהנים בראשם תקין

440
00:20:24,550 --> 00:20:27,400
עכשיו, אז אני אראה אותך בשעתי עבודה
וכל TFS יראה אותך ו

441
00:20:27,400 --> 00:20:29,460
הם יגידו, יראו לי איך להשתמש
GDB, ותוכל

442
00:20:29,460 --> 00:20:31,240
כדי להראות להם, נכון?

443
00:20:31,240 --> 00:20:31,760
סוג של?

444
00:20:31,760 --> 00:20:32,640
אולי בתקווה.

445
00:20:32,640 --> 00:20:33,670
מגניב.

446
00:20:33,670 --> 00:20:35,790
>> אז אנחנו הולכים לעבור ל
מיון וחיפוש.

447
00:20:35,790 --> 00:20:40,710
תראה יש לי רשימה כבר מסודרים
עבורנו, אבל זה לא הולך

448
00:20:40,710 --> 00:20:42,220
להיות המקרה תמיד.

449
00:20:42,220 --> 00:20:49,170
אז בבעיה להגדיר מפרט
בעיה להגדיר שלוש, יש לך מכנסיים קצרים

450
00:20:49,170 --> 00:20:51,410
שאתה יכול לצפות, וזה ממש
שואל אותך לצפות במכנסים האלה.

451
00:20:51,410 --> 00:20:55,090
כמו כן, בהרצאה בשבוע שעבר, הלכנו על
הרבה האלגוריתמים האלה, ולכן אני

452
00:20:55,090 --> 00:20:59,150
לא הולך לבלות את הזמן בכיתה הולך
על האלגוריתמים האלה שוב או ציור

453
00:20:59,150 --> 00:21:01,130
תמונות לכיצד אלה
אלגוריתמים עובדים.

454
00:21:01,130 --> 00:21:04,030
שוב, זה מידע שאתה יכול מחדש את שעון
הרצאה, או מידע ש

455
00:21:04,030 --> 00:21:08,570
הוא נתפס יוצאת מן הכלל במכנסיים הקצרים
לחיפושים הללו, כל

456
00:21:08,570 --> 00:21:10,920
אשר זמינים בcs50.net.

457
00:21:10,920 --> 00:21:14,200
>> אז במקום, מה אנחנו הולכים
לעשות הוא לכתוב תוכניות אלה.

458
00:21:14,200 --> 00:21:18,190
יש לנו תחושה, מודל המנטלי, של איך
הם עובדים, ואז מה שאנחנו הולכים

459
00:21:18,190 --> 00:21:20,210
לעשות הוא לקודד אותם לאמיתית.

460
00:21:20,210 --> 00:21:23,430
אנחנו הולכים להפוך את זה מודל המנטלי,
תמונה, אם תרצה, ל

461
00:21:23,430 --> 00:21:24,960
קוד בפועל.

462
00:21:24,960 --> 00:21:28,460
ואם הייתם קצת מבולבלים או
מעורפל על המודל המנטלי, אני לגמרי

463
00:21:28,460 --> 00:21:28,770
להבין.

464
00:21:28,770 --> 00:21:30,540
>> אנחנו לא באמת הולכים
לקפוץ ישר קוד.

465
00:21:30,540 --> 00:21:36,030
אז בזמן שהפקודה הזאת בשקופית זו שואלת
לך קוד חיפוש בינארי, ו

466
00:21:36,030 --> 00:21:39,470
למעשה, גרסה חוזרת ונשנית של
החיפוש בינארי, הדבר הראשון שאני

467
00:21:39,470 --> 00:21:42,370
באמת רוצה לעשות הוא
לכתוב כמה pseudocode.

468
00:21:42,370 --> 00:21:47,020
אז יש לך מודל המנטלי הזה
כיצד בינארי עבודות חיפוש.

469
00:21:47,020 --> 00:21:50,060
קח את גיליון נייר אם יש לך
אחד זמין, או לפתוח את

470
00:21:50,060 --> 00:21:52,520
עורך טקסט, ואני רוצה
כולם לכתוב.

471
00:21:52,520 --> 00:21:57,470
קח ארבע דקות כדי לכתוב את
pseudocode לחיפוש בינארי.

472
00:21:57,470 --> 00:21:58,990
>> שוב, תחשוב על זה מודל המנטלי.

473
00:21:58,990 --> 00:22:01,980
אני אבוא מסביב אם יש לך שאלות
ואנחנו יכולים לצייר את התמונה.

474
00:22:01,980 --> 00:22:06,220
אבל קודם כל, לפני שאנחנו מתחילים בתכנות,
אני רוצה לכתוב

475
00:22:06,220 --> 00:22:09,920
pseudocode לחיפוש בינארי ולכן כאשר אנו
לצלול פנימה, יש לנו כמה כיוון כמו

476
00:22:09,920 --> 00:22:12,110
לשם אנחנו צריכים בראש.

477
00:22:12,110 --> 00:22:15,330
>> תלמיד: האם אנחנו יכולים להניח את המערך של
ערכים שאנו מקבלים כבר ממוינים?

478
00:22:15,330 --> 00:22:17,960
>> ג'ייסון הירשהורן: אז לחיפוש בינארי
לעבודה - שאלה מצוינת - לך

479
00:22:17,960 --> 00:22:20,970
צריך לקחת בממוין
מערך של ערכים.

480
00:22:20,970 --> 00:22:22,290
אז תניח שזה יעבוד.

481
00:22:22,290 --> 00:22:23,480
אנחנו נחזור לשקופית זו.

482
00:22:23,480 --> 00:22:27,220
אתה תראה בסגול הפונקציה
הכרזה היא int binary_search bool

483
00:22:27,220 --> 00:22:29,230
ערך, ערכי int, n int.

484
00:22:29,230 --> 00:22:32,910
זה צריך להיראות מוכר אם יש לך
כבר פנו או קבל

485
00:22:32,910 --> 00:22:34,580
ידיים מלוכלכות עם סט הבעיה.

486
00:22:34,580 --> 00:22:35,910
>> אבל זה ההצהרה על הפונקציה שלך.

487
00:22:35,910 --> 00:22:39,080
שוב, אין צורך לדאוג
כל כך הרבה בשלב זה.

488
00:22:39,080 --> 00:22:43,660
מה אני באמת רוצה לעשות זה לקחת
ארבע דקות לינארי pseudocode

489
00:22:43,660 --> 00:22:46,380
חיפוש, ואחר כך נלך
על זה כקבוצה.

490
00:22:46,380 --> 00:22:47,500
ואני אבוא בסביבה.

491
00:22:47,500 --> 00:22:49,590
אם יש לך שאלות, מרגיש
חופשי להרים את היד שלך.

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

493
00:25:07,110 --> 00:25:09,680
>> למה אתה לא לוקח שתי דקות נוספות
כדי לסיים את pseudocode?

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

495
00:25:13,690 --> 00:25:15,820
אני יודע שזה אולי נראה מגוחך, כי
אנחנו מבלים כל כך הרבה זמן על

496
00:25:15,820 --> 00:25:20,350
משהו שהוא אפילו לא ממש ב
C, אך במיוחד עבור אלה יותר

497
00:25:20,350 --> 00:25:24,030
אלגוריתמים והבעיה מאתגרים
סטים שיש לנו כדי להבין,

498
00:25:24,030 --> 00:25:27,210
מתחיל בpseudocode לא לדאוג
על התחביר, רק לדאוג

499
00:25:27,210 --> 00:25:29,150
ההיגיון, הוא מועיל מאוד.

500
00:25:29,150 --> 00:25:32,720
וככה, אתה לא לפתרון שני
בעיות קשות מאוד ובעונה אחת.

501
00:25:32,720 --> 00:25:35,390
אתה פשוט מתמקד בהיגיון, ו
אז אתה לעבור לתחביר.

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

503
00:25:59,960 --> 00:26:01,385
>> על אישור.

504
00:26:01,385 --> 00:26:03,680
בואו נתחיל עובר
pseudocode.

505
00:26:03,680 --> 00:26:05,380
שכתבתי עד כאן, בינארי
pseudocode חיפוש.

506
00:26:05,380 --> 00:26:07,360
אנחנו כותבים את זה על
לעלות ביחד.

507
00:26:07,360 --> 00:26:10,040
או שאני אכתוב את זה, ואתה תיתן לי
שלי את ההנחיות שאני צריך.

508
00:26:10,040 --> 00:26:15,010
אז מישהו יכול לתת לי את הראשון
קו של pseudocode

509
00:26:15,010 --> 00:26:18,350
כתב לחיפוש בינארי?

510
00:26:18,350 --> 00:26:20,258
כן, אנני?

511
00:26:20,258 --> 00:26:22,698
>> תלמיד: בעוד שאורכו של
הרשימה היא גדולה מאפס.

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

513
00:26:26,114 --> 00:26:34,880
>> ג'ייסון הירשהורן: בעוד אורך
רשימה גדולה מאפס.

514
00:26:34,880 --> 00:26:38,810
ושוב, אנו רואים כמה C-מחפשים
דברים תחביריים כאן.

515
00:26:38,810 --> 00:26:41,550
אבל יותר מזה הוא באנגלית.

516
00:26:41,550 --> 00:26:43,980
האם למישהו יש שורה הם שמו
לפני זה בפסאודו הקוד שלהם?

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

518
00:26:47,280 --> 00:26:50,210
>> תלמיד: קבל מערך
של מסודרים מספרים.

519
00:26:50,210 --> 00:26:53,600
>> ג'ייסון הירשהורן: אתה כתב "לקבל
מערך של מספרים ממוינים. "Per

520
00:26:53,600 --> 00:26:56,140
הצהרה על פונקציה, אנחנו נהיה עוברים
מערך של מספרי מיון.

521
00:26:56,140 --> 00:26:57,280
>> תלמיד: [לא ברור].

522
00:26:57,280 --> 00:26:59,030
>> ג'ייסון הירשהורן: אז
תהיה לנו את זה.

523
00:26:59,030 --> 00:27:01,820
אבל כן, אם לא היה לנו את זה, אנחנו
היית צריך למיין את המערך שלנו

524
00:27:01,820 --> 00:27:04,850
מספרים, כי חיפוש בינארי
עובד רק על מערכים ממוינים.

525
00:27:04,850 --> 00:27:11,300
אז בזמן שאורך של רשימה שווה אפס, אני
הולך לשים בחלק סוגריים מסולסלים

526
00:27:11,300 --> 00:27:15,420
כדי לגרום לזה להיראות קצת יותר כמו
נראה C. אבל זמן מה, למפה על

527
00:27:15,420 --> 00:27:19,550
תוך לולאה, ולכן בתוך הזמן הזה
לולאה מה שאנחנו צריכים לעשות כדי

528
00:27:19,550 --> 00:27:22,000
לעשות לחיפוש בינארי?

529
00:27:22,000 --> 00:27:25,530
>> מישהו אחר שלא נתן לי
תשובה עדיין, אבל מי כתב את זה?

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

531
00:27:31,750 --> 00:27:33,320
>> תלמיד: לכו לאמצע הרשימה.

532
00:27:33,320 --> 00:27:33,980
>> ג'ייסון הירשהורן: טום.

533
00:27:33,980 --> 00:27:35,230
עבור לאמצע הרשימה.

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

535
00:27:43,290 --> 00:27:45,530
ושאלת המעקב, מה
אנחנו עושים ברגע שאנחנו נמצאים בבית

536
00:27:45,530 --> 00:27:46,870
אמצע הרשימה?

537
00:27:46,870 --> 00:27:49,310
>> תלמיד: האם לבדוק אם זה
המספר שאתה מחפש.

538
00:27:49,310 --> 00:27:50,120
>> ג'ייסון הירשהורן: מצוין.

539
00:27:50,120 --> 00:28:05,500
לכו אמצע הרשימה ולבדוק
אם הערך שלנו נמצא שם -

540
00:28:05,500 --> 00:28:06,515
פנטסטי.

541
00:28:06,515 --> 00:28:10,460
האם יש למישהו כל דבר אחר
זה היה שונה מזה?

542
00:28:10,460 --> 00:28:11,210
זה בדיוק נכון.

543
00:28:11,210 --> 00:28:13,800
>> הדבר הראשון שאנחנו עושים בחיפוש בינארי
הוא הולך לאמצע הרשימה ו

544
00:28:13,800 --> 00:28:15,870
לבדוק אם הערך שלנו הוא שם.

545
00:28:15,870 --> 00:28:19,682
אז אני מניח שאם הערך שלנו הוא
שם, מה אנחנו עושים?

546
00:28:19,682 --> 00:28:21,610
>> תלמיד: אנחנו חוזרים אפס [לא ברורים].

547
00:28:21,610 --> 00:28:23,400
>> ג'ייסון הירשהורן: כן, אם
הערך הוא שם, מצאנו אותו.

548
00:28:23,400 --> 00:28:27,950
אז אנחנו יכולים לספר לי דרך כלשהי, אולם זה
פונקציה מוגדרת, אנו אומרים לי המשתמש

549
00:28:27,950 --> 00:28:28,520
אנחנו מצאנו אותו.

550
00:28:28,520 --> 00:28:30,950
אם זה לא שם, אם כי, זה
שבו זה נהיה מסובך.

551
00:28:30,950 --> 00:28:35,120
אז אם זה לא שם, מישהו אחר ש
היה עובד על חיפוש או בינארי

552
00:28:35,120 --> 00:28:36,830
יש רעיון עכשיו, מה אנחנו עושים?

553
00:28:36,830 --> 00:28:37,830
>> תלמיד: שאלה.

554
00:28:37,830 --> 00:28:38,100
>> ג'ייסון הירשהורן: כן?

555
00:28:38,100 --> 00:28:39,920
>> סטודנט: האם המערך כבר ממוין?

556
00:28:39,920 --> 00:28:42,200
>> ג'ייסון הירשהורן: כן, אנחנו מניחים
המערך כבר ממוין.

557
00:28:42,200 --> 00:28:46,480
>> תלמיד: אז אתה צריך לבדוק אם
הערך שאתה רואה הוא גדול יותר מאשר

558
00:28:46,480 --> 00:28:51,745
את הערך שאתה רוצה, אתה יכול להזיז
באמצע המחצית השנייה.

559
00:28:51,745 --> 00:28:54,110
>> ג'ייסון הירשהורן: אז אם באמצע
הרשימה היא גדולה יותר ממה שאנחנו

560
00:28:54,110 --> 00:28:57,440
מחפש, אז אנחנו עושים מה?

561
00:28:57,440 --> 00:28:58,320
אנחנו עוברים בו?

562
00:28:58,320 --> 00:29:01,400
>> סטודנט: אתה רוצה לעבור ל
מחצית מהרשימה עם

563
00:29:01,400 --> 00:29:02,780
מספרים נמוכים מזה.

564
00:29:02,780 --> 00:29:04,460
>> ג'ייסון הירשהורן: אז אנחנו
קורא לזה השמאל.

565
00:29:04,460 --> 00:29:15,435
אז אם האמצע הוא גדול יותר, אנחנו יכולים לחפש
המחצית השמאלית של הרשימה.

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

567
00:29:20,620 --> 00:29:22,980
ולאחר מכן על ידי חיפוש, מה
אני מתכוון בחיפוש?

568
00:29:22,980 --> 00:29:24,010
>> תלמיד: [לא ברור].

569
00:29:24,010 --> 00:29:24,410
>> ג'ייסון הירשהורן: אנחנו הולכים לאמצע.

570
00:29:24,410 --> 00:29:25,740
אנחנו בעצם חוזרים על הדבר הזה.

571
00:29:25,740 --> 00:29:29,210
אנחנו חוזרים דרך הלולאה בזמננו.

572
00:29:29,210 --> 00:29:31,480
אני אתן לך את האחרון -

573
00:29:31,480 --> 00:29:39,047
אחר, אם, באמצע הוא פחות ממה
שאנחנו עושים, מה אנחנו עושים כאן?

574
00:29:39,047 --> 00:29:40,360
>> תלמיד: לכו לצד ימין.

575
00:29:40,360 --> 00:29:41,610
>> ג'ייסון הירשהורן: חיפוש מימין.

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

577
00:29:47,440 --> 00:29:51,710
זה נראה טוב, אבל האם יש למישהו
כל דבר שאנו עשויים להיות חסרים או

578
00:29:51,710 --> 00:29:53,200
כל דבר אחר שאתה מכניס
בפסאודו הקוד שלך?

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

580
00:29:57,080 --> 00:29:58,410
אז זה מה שיש לנו עד כה.

581
00:29:58,410 --> 00:30:00,960
בעוד שאורכה של הרשימה הוא גדול יותר
מאפס, אנחנו הולכים ללכת

582
00:30:00,960 --> 00:30:03,220
לאמצע הרשימה ו
לבדוק אם הערך שלנו הוא שם.

583
00:30:03,220 --> 00:30:06,970
>> אם באמצע הוא גדול יותר, אנחנו הולכים
חיפוש שמאלה, אחר אם האמצע הוא

584
00:30:06,970 --> 00:30:09,230
פחות, אנחנו הולכים לחפש את הזכות.

585
00:30:09,230 --> 00:30:14,430
אז יש את כל שהיו לנו היכרות מסוימת עם
המונחים שהשתמשנו במדעי מחשב

586
00:30:14,430 --> 00:30:15,550
ואת הכלים שיש לנו.

587
00:30:15,550 --> 00:30:18,300
אבל אתה כבר שם לב שהיינו
מדבר באנגלית, אבל מצאנו

588
00:30:18,300 --> 00:30:24,790
הרבה דברים שנראו למפה על
כלים שיש לנו בערכת כלי עבודת הקידוד שלנו.

589
00:30:24,790 --> 00:30:27,210
אז מייד את הבת, אנחנו לא
הולך לקודד למעשה עדיין.

590
00:30:27,210 --> 00:30:33,300
>> מה אנחנו רואים כאן באנגלית שמפות
לדברים שאנחנו יכולים לכתוב ב-C?

591
00:30:33,300 --> 00:30:34,560
>> תלמיד: בעוד.

592
00:30:34,560 --> 00:30:35,320
>> ג'ייסון הירשהורן: בעוד.

593
00:30:35,320 --> 00:30:40,610
אז בזמן שזה ממש כאן
מפות על מה?

594
00:30:40,610 --> 00:30:42,630
>> תלמיד: לולאה בזמן.

595
00:30:42,630 --> 00:30:43,200
>> ג'ייסון הירשהורן: לולאה בזמן?

596
00:30:43,200 --> 00:30:44,540
או כנראה, באופן כללי יותר, לולאה.

597
00:30:44,540 --> 00:30:46,260
אנחנו רוצים לעשות משהו שוב ושוב.

598
00:30:46,260 --> 00:30:49,050
אז אנחנו הולכים לקוד לולאה.

599
00:30:49,050 --> 00:30:51,640
ואנחנו כבר יודעים, כי מה שעשינו
זה כמה פעמים ואנחנו

600
00:30:51,640 --> 00:30:54,180
יש שפע של דוגמאות שם בחוץ,
איך בעצם לכתוב

601
00:30:54,180 --> 00:30:55,310
מדד זה ללולאה.

602
00:30:55,310 --> 00:30:56,160
אז זה צריך להיות די קל.

603
00:30:56,160 --> 00:30:58,070
אנחנו צריכים להיות מסוגלים לקבל את זה
התחיל די מהר.

604
00:30:58,070 --> 00:31:01,830
>> מה עוד שאנו רואים כאן?

605
00:31:01,830 --> 00:31:06,820
מה אחר מבני תחביר, דברים
שאנחנו מכירים ב-C, לעשות לנו

606
00:31:06,820 --> 00:31:09,790
כבר יש תחושה מבוססת
הנחה של המילים שאנחנו משתמשים בה?

607
00:31:09,790 --> 00:31:10,830
כן, אנה?

608
00:31:10,830 --> 00:31:11,360
[לא ברור]

609
00:31:11,360 --> 00:31:12,990
סתם, בצחוק.

610
00:31:12,990 --> 00:31:13,540
אנה, קדימה.

611
00:31:13,540 --> 00:31:14,530
>> תלמיד: אם ואחר.

612
00:31:14,530 --> 00:31:16,260
>> ג'ייסון הירשהורן: אם ו
אחר - ממש כאן.

613
00:31:16,260 --> 00:31:18,840
אז מה אלה נראים?

614
00:31:18,840 --> 00:31:20,420
>> תלמיד: אם הצהרה אחרת.

615
00:31:20,420 --> 00:31:21,560
>> ג'ייסון הירשהורן: כן,
תנאים, נכון?

616
00:31:21,560 --> 00:31:24,650
אז אנחנו בטח צריכים
לכתוב כמה תנאים.

617
00:31:24,650 --> 00:31:31,185
ושוב, אם כי אולי מבלבל ב
, בדרך כלל יש לנו תחושה הראשונה עכשיו

618
00:31:31,185 --> 00:31:34,010
של איך לכתוב תנאים ו
התחביר לתנאים.

619
00:31:34,010 --> 00:31:36,850
ואם לא אנחנו, אנחנו רק להסתכל למעלה
תחביר לתנאים, לגזור ולהדביק

620
00:31:36,850 --> 00:31:39,950
את זה, כי אנחנו יודעים שאנחנו
צריך מצב כאן.

621
00:31:39,950 --> 00:31:44,910
כל דברים אחרים שאנחנו רואים מפה שעל גבי
דברים שאולי צריך לעשות ב-C?

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

623
00:31:48,312 --> 00:31:48,960
כן, שלמה ע"ה?

624
00:31:48,960 --> 00:31:50,370
>> תלמיד: זה יכול להיות מובן מאליו,
רק על ידי בדיקה אם

625
00:31:50,370 --> 00:31:51,990
ערך שווה משהו.

626
00:31:51,990 --> 00:31:54,578
>> ג'ייסון הירשהורן: אז איך לבדוק
ועל - כן ללכת לאמצע הרשימה

627
00:31:54,578 --> 00:31:55,610
ולבדוק אם הערך שלנו הוא שם?

628
00:31:55,610 --> 00:31:56,570
איך אנחנו עושים את זה ב-C?

629
00:31:56,570 --> 00:31:58,450
מה התחביר לזה?

630
00:31:58,450 --> 00:31:59,235
>> סטודנט: שווה, שווה.

631
00:31:59,235 --> 00:32:00,650
>> ג'ייסון הירשהורן: שווה, שווה.

632
00:32:00,650 --> 00:32:03,540
אז סימון זו כנראה הולך
להיות שווה, שווה.

633
00:32:03,540 --> 00:32:04,510
אז נדע שאנחנו צריכים מקום ש.

634
00:32:04,510 --> 00:32:07,510
ולמעשה, רק בכתיבתו,
אנו רואים דברים אחרים.

635
00:32:07,510 --> 00:32:11,400
אנחנו הולכים לעשות קצת
מפעילי השוואה לשם -

636
00:32:11,400 --> 00:32:12,010
פנטסטי.

637
00:32:12,010 --> 00:32:14,980
אז זה באמת נראה, על ידי ו
גדול, יש לנו לא כתובים

638
00:32:14,980 --> 00:32:16,390
מילה של קוד C עדיין.

639
00:32:16,390 --> 00:32:20,610
אבל יש לנו את המודל המנטלי למטה
באמצעות הרצאות ומכנסיים קצרים אלה.

640
00:32:20,610 --> 00:32:22,350
>> כתבנו פסאודו קוד כקבוצה.

641
00:32:22,350 --> 00:32:27,110
וכבר, יש לנו 80% אם לא
90% ממה שאנחנו צריכים לעשות.

642
00:32:27,110 --> 00:32:28,550
עכשיו, אנחנו רק צריכים לקודד
זה, שבו שוב, הוא

643
00:32:28,550 --> 00:32:30,110
בעיה לא טריוויאלית לפתרון.

644
00:32:30,110 --> 00:32:31,890
אבל לפחות אנחנו תקועים בהיגיון.

645
00:32:31,890 --> 00:32:38,040
לפחות עכשיו, כאשר אנחנו הולכים לשעתי עבודה,
אני יכול להגיד, אני יודע מה אני צריך

646
00:32:38,040 --> 00:32:40,160
לעשות, אבל אתה יכול להזכיר לי
לי את התחביר?

647
00:32:40,160 --> 00:32:42,940
או אפילו אם שעתי עבודה עמוסות, אתה
יכול לגגל לתחביר, ולא

648
00:32:42,940 --> 00:32:45,040
מאשר להיות תקוע בהיגיון.

649
00:32:45,040 --> 00:32:48,570
>> ושוב, ולא מנסה לפתור
ההיגיון ובעיות התחביר כל

650
00:32:48,570 --> 00:32:51,900
בבת אחת, הוא לעתים קרובות הרבה יותר טוב
לנתק את שתי הבעיות קשות האלה לתוך

651
00:32:51,900 --> 00:32:58,280
שני יותר לניהול אלה ולעשות
פסאודו קוד ראשון ולאחר מכן בג

652
00:32:58,280 --> 00:33:00,620
אז בואו תראה את מה שעשיתי עבור
פסאודו קוד מבעוד מועד.

653
00:33:00,620 --> 00:33:04,060
>> בעוד שאורכה של הרשימה הוא גדול יותר
מאפס, מסתכל על האמצע

654
00:33:04,060 --> 00:33:05,090
של הרשימה.

655
00:33:05,090 --> 00:33:09,610
אם מספר מצא חזר נכון, אחר
אם שמאל חיפוש, מספר גבוה יותר.

656
00:33:09,610 --> 00:33:13,200
אחר אם מספר, חיפוש נמוך
ימין, בתמורת שווא.

657
00:33:13,200 --> 00:33:18,710
כך שנראה כמעט זהה, אם לא
כמעט זהה למה שאנחנו כתבנו.

658
00:33:18,710 --> 00:33:23,030
למעשה, טום, מה שאמרת קודם,
לשבור את אמצע הרשימה ואם

659
00:33:23,030 --> 00:33:24,880
מספר מצא לשתי הצהרות
הוא למעשה מה שעשיתי.

660
00:33:24,880 --> 00:33:25,507
>> שילבתי אותם שם.

661
00:33:25,507 --> 00:33:27,100
הייתי צריך להקשיב ל
שלך בפעם הראשונה.

662
00:33:27,100 --> 00:33:30,640
אז זה פסאודו הקוד יש לנו.

663
00:33:30,640 --> 00:33:35,060
אם אתה רוצה עכשיו, סליחה, תלך
תחזור לבעיה הראשונית שלנו.

664
00:33:35,060 --> 00:33:37,780
בואו binary.c קוד.

665
00:33:37,780 --> 00:33:40,870
אז ליישם גרסה חוזרת ונשנית של
חיפוש בינארי באמצעות הפעולות הבאות

666
00:33:40,870 --> 00:33:42,420
הצהרה על פונקציה.

667
00:33:42,420 --> 00:33:44,550
>> ואתה לא צריך להעתיק
את זה עדיין.

668
00:33:44,550 --> 00:33:49,470
בעצם אני הולך לפתוח
עד כאן binary.c.

669
00:33:49,470 --> 00:33:52,880
אז יש את ההצהרה על הפונקציה
באמצע המסך.

670
00:33:52,880 --> 00:33:57,570
ואתם תראו שלקחתי פסאודו הקוד
משני צדיי, אבל כמעט זהה

671
00:33:57,570 --> 00:33:59,740
למה שכתבנו, ו
לשים את זה בשבילך.

672
00:33:59,740 --> 00:34:06,010
אז עכשיו, בואו ניקח חמש דקות
קוד בפונקציה זו.

673
00:34:06,010 --> 00:34:08,199
>> ושוב, אם יש לך שאלות,
להרים את היד שלך, תודיע לי, אני

674
00:34:08,199 --> 00:34:08,710
לבוא מסביב.

675
00:34:08,710 --> 00:34:09,800
>> תלמיד: [לא ברור].

676
00:34:09,800 --> 00:34:12,380
>> ג'ייסון הירשהורן: אז לקחתי את ינארי
הגדרת חיפוש ב

677
00:34:12,380 --> 00:34:14,429
למעלה, על קו 12.

678
00:34:14,429 --> 00:34:16,429
זה מה שיש לי לשקופית שלי.

679
00:34:16,429 --> 00:34:20,940
ואז כל פסאודו הקוד הזה אני רק
להעתיק ולהדביק מהשקופית,

680
00:34:20,940 --> 00:34:22,190
שקופיות פסאודו קוד.

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

682
00:35:22,830 --> 00:35:26,786
אני עדיין לא שמעתי [לא ברור].

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

684
00:37:13,010 --> 00:37:15,820
>> אז אם יש לך סיימת
יישום, אני רוצה לבדוק את זה.

685
00:37:15,820 --> 00:37:19,410
אני בדוא"ל לך את קובץ helpers.h
מוקדם יותר במעמד הזה.

686
00:37:19,410 --> 00:37:22,360
והוא יהיה זמין באינטרנט, כמו גם
להורדה עבור אנשים צופים

687
00:37:22,360 --> 00:37:24,750
זמן סעיף זה מתעכב.

688
00:37:24,750 --> 00:37:29,350
ואני רק השתמשתי בהפצה הגנרית
קוד מpset3.

689
00:37:29,350 --> 00:37:34,590
אז לקחתי find.C, משתמש בקובץ helpers.h
ולא את קובץ helpers.h

690
00:37:34,590 --> 00:37:36,280
שנתן בקוד ההפצה.

691
00:37:36,280 --> 00:37:39,310
>> והייתי צריך לעשות שינוי אחר באחד
find.C ולא קוראים פשוט

692
00:37:39,310 --> 00:37:42,770
חיפוש, קורא binary_search.

693
00:37:42,770 --> 00:37:49,080
אז אם אתה רוצה לבדוק את הקוד שלך,
יודע שזה הוא איך לעשות את זה.

694
00:37:49,080 --> 00:37:52,530
למעשה, כאשר אנחנו ננהל את הקוד הזה
כרגע, אני פשוט עושה עותק של

695
00:37:52,530 --> 00:37:59,820
ספריית pset3 שלי, שוב, החליף את
קבצי עוזרים ולאחר מכן עשו את זה

696
00:37:59,820 --> 00:38:04,695
לשנות בfind.C לקרוא binary_search
ולא רק לחפש.

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

698
00:40:08,620 --> 00:40:09,120
>> ג'ייסון הירשהורן: כן.

699
00:40:09,120 --> 00:40:11,258
יש לך שאלה?

700
00:40:11,258 --> 00:40:12,150
>> תלמיד: Nevermind.

701
00:40:12,150 --> 00:40:12,600
>> ג'ייסון הירשהורן: אין בעיה.

702
00:40:12,600 --> 00:40:13,370
ובכן, בואו נתחיל.

703
00:40:13,370 --> 00:40:15,090
אנו קוד זה כקבוצה.

704
00:40:15,090 --> 00:40:16,050
פתק אחד אחר.

705
00:40:16,050 --> 00:40:20,600
שוב, זה, יכול בקלות להיות מוחלף
לבעית סט שלושה.

706
00:40:20,600 --> 00:40:25,530
יש לי קובץ helpers.h אשר, ולא
מ helpers.h אנחנו נתון,

707
00:40:25,530 --> 00:40:28,560
מכריז חיפוש בינארי, בועה
למיין ומיון בחירה.

708
00:40:28,560 --> 00:40:37,400
ובfind.c תוכל להבחין בקו,
מה זה, קו 68, אנחנו קוראים לינארי

709
00:40:37,400 --> 00:40:39,160
חיפוש ולא חיפוש.

710
00:40:39,160 --> 00:40:42,930
אז שוב, את הקוד, כי הוא זמין
באינטרנט או את הקוד שאתה

711
00:40:42,930 --> 00:40:46,590
יצירת עכשיו יכול להיות החליף בקלות
לעמ להגדיר 3 כדי לבדוק את זה.

712
00:40:46,590 --> 00:40:50,620
>> אבל קודם, בואו קוד החיפוש בינארי.

713
00:40:50,620 --> 00:40:53,690
ההצהרה על הפונקציה שלנו,
אנחנו חוזרים בול.

714
00:40:53,690 --> 00:40:55,810
אנחנו לוקחים את מספר שלם שנקרא ערך.

715
00:40:55,810 --> 00:40:59,285
אנחנו לוקחים את המערך של מספרים שלמים הנקרא
ערכים, ואנחנו לוקחים את n להיות

716
00:40:59,285 --> 00:41:00,850
גודלו של המערך.

717
00:41:00,850 --> 00:41:05,640
על קו 10, ממש כאן, יש לי
חדה כוללת stdbool.h.

718
00:41:05,640 --> 00:41:07,360
האם מישהו יודע למה זה שם?

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

720
00:41:12,180 --> 00:41:16,600
אז מה שורה זו של קוד לעשות?

721
00:41:16,600 --> 00:41:19,880
>> תלמיד: זה מאפשר לך
להשתמש בסוג החזרת bool.

722
00:41:19,880 --> 00:41:20,350
>> ג'ייסון הירשהורן: בדיוק.

723
00:41:20,350 --> 00:41:22,300
>> תלמיד: או שזה ספרייה המאפשרת
להשתמש בסוג החזרת bool.

724
00:41:22,300 --> 00:41:27,590
>> ג'ייסון הירשהורן: אז החד כולל
שורת stdbool.h נותנת לי קצת

725
00:41:27,590 --> 00:41:31,340
הגדרות והצהרות לדברים
שמותר לי להשתמש ב

726
00:41:31,340 --> 00:41:32,400
ספרייה זו.

727
00:41:32,400 --> 00:41:36,570
אז בין אלה שאומר שיש
סוג זה נקרא בול, וזה יכול להיות

728
00:41:36,570 --> 00:41:37,750
אמת או שקר.

729
00:41:37,750 --> 00:41:39,010
אז זה מה שעושה את השורה.

730
00:41:39,010 --> 00:41:41,680
ואם לא היה לי קו שאני היית עושה
להסתבך עבור כותב את זה

731
00:41:41,680 --> 00:41:43,520
מילה נכונה כאן, בול, בדיוק שם.

732
00:41:43,520 --> 00:41:44,140
בדיוק נכון.

733
00:41:44,140 --> 00:41:46,430
אז אני צריך את זה בקוד זה.

734
00:41:46,430 --> 00:41:47,690
על אישור.

735
00:41:47,690 --> 00:41:51,860
אז זה, שוב, הוא איטרטיבי
גרסה, לא אחד רקורסיבית.

736
00:41:51,860 --> 00:41:53,820
אז בואו נתחיל.

737
00:41:53,820 --> 00:41:56,200
>> בואו נתחיל עם זה ראשון
שורת קוד פסאודו.

738
00:41:56,200 --> 00:41:58,770
ובתקווה, גם אנחנו -
או לא בתקווה.

739
00:41:58,770 --> 00:42:00,530
אנחנו הולכים להסתובב בחדר.

740
00:42:00,530 --> 00:42:05,110
נלך שורה אחרת שורה, ואני נעזור לי
לך להבין את הקו שאנחנו צריכים

741
00:42:05,110 --> 00:42:06,310
כדי לכתוב ראשון.

742
00:42:06,310 --> 00:42:10,550
אז בזמן שאורך הרשימה
הוא גדול מאפס.

743
00:42:10,550 --> 00:42:12,680
בואו נתחיל בחלק הקדמי.

744
00:42:12,680 --> 00:42:15,190
מה קו שאני צריך לכתוב
כאן, בקוד?

745
00:42:15,190 --> 00:42:19,470
>> תלמיד: בעוד סוגריים
n הוא גדול מ -0.

746
00:42:19,470 --> 00:42:21,900
>> ג'ייסון הירשהורן: בעוד
n הוא גדול מ -0.

747
00:42:21,900 --> 00:42:26,550
אז n הוא בגודל של רשימה,
ואנחנו בודקים אם -

748
00:42:26,550 --> 00:42:26,800
>> [קולות חציצה]

749
00:42:26,800 --> 00:42:27,660
>> ג'ייסון הירשהורן: - סליחה?

750
00:42:27,660 --> 00:42:29,360
>> תלמיד: איך אנחנו יודעים ש
n הוא בגודל של הרשימה?

751
00:42:29,360 --> 00:42:29,690
>> ג'ייסון הירשהורן: מצטער.

752
00:42:29,690 --> 00:42:34,690
למפרט pset, החיפוש
וסוג פונקציות שאתה צריך לכתוב,

753
00:42:34,690 --> 00:42:36,230
n הוא בגודל של הרשימה.

754
00:42:36,230 --> 00:42:37,710
שכחתי להסביר את זה כאן.

755
00:42:37,710 --> 00:42:41,310
אבל כן. n הוא בגודל של
הרשימה, במקרה זה.

756
00:42:41,310 --> 00:42:44,740
וכך, בעוד n הוא גדול מ -0.

757
00:42:44,740 --> 00:42:45,580
על אישור.

758
00:42:45,580 --> 00:42:50,090
שעשוי להוכיח קצת בעייתי
אם כי, אם הדברים הולכים הלאה.

759
00:42:50,090 --> 00:42:54,510
מכיוון שאנחנו נמשיך לדעת
גודלה של הרשימה בכל זה

760
00:42:54,510 --> 00:43:06,640
פונקציה, אבל אומרת שאנחנו מתחילים את
עם מערך של 5 מספרים שלמים.

761
00:43:06,640 --> 00:43:08,950
ואנחנו עוברים ויש לנו
החברה צמצם את זה עד

762
00:43:08,950 --> 00:43:10,310
מערך של 2 מספרים שלמים.

763
00:43:10,310 --> 00:43:12,160
איזה 2 מספרים שלמים הוא זה?

764
00:43:12,160 --> 00:43:15,895
הגודל הוא 2 החברה שאנחנו רוצים
להסתכל, אבל ש2 הוא זה?

765
00:43:15,895 --> 00:43:17,720
האם זה הגיוני, את השאלה הזאת?

766
00:43:17,720 --> 00:43:18,020
>> על אישור.

767
00:43:18,020 --> 00:43:19,120
אני אשאל את זה שוב.

768
00:43:19,120 --> 00:43:26,640
אז אנחנו מתחילים עם המערך הזה של 5
מספרים שלמים, וn שווה 5, נכון?

769
00:43:26,640 --> 00:43:28,050
אנחנו לרוץ דרך כאן.

770
00:43:28,050 --> 00:43:31,560
אנחנו בטח לשנות את הגודל,
נכון, כדברים הולכים הלאה.

771
00:43:31,560 --> 00:43:32,700
וזה מה שאנחנו אומרים שאנחנו רוצים לעשות.

772
00:43:32,700 --> 00:43:34,150
אנחנו לא רוצים לחפש
הדבר המלא שוב.

773
00:43:34,150 --> 00:43:35,480
אז אומר לנו לשנות את זה ל -2.

774
00:43:35,480 --> 00:43:36,970
אנחנו לוקחים חצי מהרשימה שזה מוזר.

775
00:43:36,970 --> 00:43:38,800
אז פשוט לקחת 2.

776
00:43:38,800 --> 00:43:40,590
אז עכשיו n שווה 2.

777
00:43:40,590 --> 00:43:42,780
אני מתנצל על העניים
סמנים יבשים למחוק.

778
00:43:42,780 --> 00:43:43,080
נכון?

779
00:43:43,080 --> 00:43:45,670
ואנחנו מחפשים דרך הרשימה
שוב עם רשימה של גודל 2.

780
00:43:45,670 --> 00:43:48,580
ובכן, המערך שלנו הוא עדיין בגודל 5.

781
00:43:48,580 --> 00:43:51,920
אנחנו אומרים רק שאנחנו רוצים
חיפוש 2 נקודות בזה.

782
00:43:51,920 --> 00:43:53,590
אז איזה 2 נקודות הם אלה?

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

784
00:43:57,640 --> 00:43:58,815
>> האם זה הגיוני?

785
00:43:58,815 --> 00:44:00,290
האם הם 2 נקודות נשארו?

786
00:44:00,290 --> 00:44:01,940
האם הם 2 נקודות הזכות?

787
00:44:01,940 --> 00:44:03,540
האם הם 2 נקודות באמצע?

788
00:44:03,540 --> 00:44:06,350
יש לנו שבור הבעיה למטה, אבל אנחנו
בעצם לא יודע באיזה חלק של

789
00:44:06,350 --> 00:44:11,600
הבעיה שאנחנו עדיין מסתכלים,
רק על ידי בעל 2 המשתנים הללו.

790
00:44:11,600 --> 00:44:16,450
אז אנחנו צריכים קצת יותר אז,
ואילו n הוא גדול מ -0.

791
00:44:16,450 --> 00:44:21,410
אנחנו צריכים לדעת איפה זה
n הוא במערך בפועל שלנו.

792
00:44:21,410 --> 00:44:26,660
>> אז האם מישהו יש לי
לשנות את הקו הזה?

793
00:44:26,660 --> 00:44:27,970
רוב של קו זה הוא
נכון באופן מושלם.

794
00:44:27,970 --> 00:44:29,170
האם יש עוד תוספת?

795
00:44:29,170 --> 00:44:32,510
האם אנחנו יכולים להחליף משהו עבור n ל
להפוך את הקו הזה קצת יותר טוב?

796
00:44:32,510 --> 00:44:32,865
מ"מ-HM?

797
00:44:32,865 --> 00:44:38,040
>> סטודנט: אתה יכול לאתחל משתנה
כמו אורך n שיהיו לאחר מכן ניתן להשתמש

798
00:44:38,040 --> 00:44:39,600
מאוחר יותר בפונקציה?

799
00:44:39,600 --> 00:44:42,060
>> ג'ייסון הירשהורן: אז לאתחל
אורך משתנה לn,

800
00:44:42,060 --> 00:44:42,900
ואנחנו משתמשים בזה מאוחר יותר?

801
00:44:42,900 --> 00:44:47,070
אבל אז אנחנו פשוט לעדכן את האורך ואנחנו
עדיין נתקל בבעיה זו שבו אנו

802
00:44:47,070 --> 00:44:51,180
לצמצם את משך הבעיה שלנו,
אבל אנחנו אף פעם לא יודעים מאיפה, בעצם,

803
00:44:51,180 --> 00:44:52,510
אורך הממפה על גבי.

804
00:44:52,510 --> 00:44:54,790
>> תלמיד: האם זה לא הולך לקרות
מאוחר יותר, כאשר אתה אומר, חיפוש עזב,

805
00:44:54,790 --> 00:44:55,746
חיפוש נכון?

806
00:44:55,746 --> 00:44:57,640
אתה מתכוון ללכת לשונה
אזור שלך -

807
00:44:57,640 --> 00:44:59,110
>> ג'ייסון הירשהורן: אנחנו הולכים ללכת
לאזור, אבל איך אנחנו יודעים

808
00:44:59,110 --> 00:45:01,150
אשר ללכת?

809
00:45:01,150 --> 00:45:03,800
אם יש לנו את המערך וזה רק
n, איך אנחנו יודעים איפה

810
00:45:03,800 --> 00:45:05,050
ללכת במערך.

811
00:45:05,050 --> 00:45:05,900
בחלק האחורי, כן?

812
00:45:05,900 --> 00:45:07,507
>> תלמיד: האם יש לך, כמו, נמוך
כפותים ומשתנה או כבול עליון

813
00:45:07,507 --> 00:45:08,586
משהו כזה?

814
00:45:08,586 --> 00:45:09,060
>> ג'ייסון הירשהורן: אישור.

815
00:45:09,060 --> 00:45:10,780
אז זה רעיון אחר.

816
00:45:10,780 --> 00:45:13,490
ולא רק שמירה על המסלול של
גודל, אנו עוקבים אחר נמוכים ו

817
00:45:13,490 --> 00:45:14,770
משתנה כבול עליון.

818
00:45:14,770 --> 00:45:17,840
אז איך לחשב את הגודל מ
חסם תחתון וחסם עליון?

819
00:45:17,840 --> 00:45:18,520
>> [קולות חציצה]

820
00:45:18,520 --> 00:45:19,710
>> ג'ייסון הירשהורן: חיסור.

821
00:45:19,710 --> 00:45:23,650
וגם שמירה על המסלול של נמוך
מחויב ועליון חייבים ליידע אותנו,

822
00:45:23,650 --> 00:45:26,215
אנחנו מחפשים שני אלה?

823
00:45:26,215 --> 00:45:28,220
האם אנו מחפשים את שני אלה לכאן?

824
00:45:28,220 --> 00:45:29,540
האם אנו מחפשים את שני האמצע?

825
00:45:29,540 --> 00:45:32,810
כנראה שלא שני האמצעיים, כי
זו, למעשה, היא החיפוש בינארי.

826
00:45:32,810 --> 00:45:37,320
אבל עכשיו נהיה מסוגל לקבל את הגודל,
אלא גם את המגבלות של המערך.

827
00:45:37,320 --> 00:45:40,020
בעיקרו של דבר, אם יש לנו ענקי שלנו
ספר טלפונים, אנחנו קורעים אותו לשתיים.

828
00:45:40,020 --> 00:45:42,990
עכשיו אנחנו יודעים איפה זה קטן יותר
ספר טלפונים הוא.

829
00:45:42,990 --> 00:45:45,260
אבל אנחנו לא ממש קורעים
ספר טלפונים במחצית.

830
00:45:45,260 --> 00:45:48,570
אנחנו עדיין צריכים לדעת איפה
גבולות חדשים של הבעיה שלנו הוא.

831
00:45:48,570 --> 00:45:51,645
האם יש למישהו שאלות
על זה?

832
00:45:51,645 --> 00:45:52,440
כן?

833
00:45:52,440 --> 00:45:56,020
>> תלמיד: האם זה עובד על ידי יצירת
משתנה, אני, כי אז אתה רק משמרת

834
00:45:56,020 --> 00:46:00,770
העמדה שלי ביחס לשלה
מיקום הנוכחי, והאורך, n?

835
00:46:00,770 --> 00:46:01,710
>> ג'ייסון הירשהורן: ומה אני?

836
00:46:01,710 --> 00:46:04,110
>> סטודנט: כמו שלהיות כמו סוג של -

837
00:46:04,110 --> 00:46:08,040
כמו שהיית לאתחל i להיות
עמדת ביניים של המערך.

838
00:46:08,040 --> 00:46:12,540
ולאחר מכן, אם הערך במיקום i ב
אמצע המערך בנמצא

839
00:46:12,540 --> 00:46:17,870
להיות נמוך מהערך שאתה צריך, אני עכשיו
הופך את האורך של המערך, בתוספת

840
00:46:17,870 --> 00:46:19,215
הערך של i מחולק על ידי 2.

841
00:46:19,215 --> 00:46:20,270
כאילו, תראה, אתה משמרת i -

842
00:46:20,270 --> 00:46:20,770
>> ג'ייסון הירשהורן: נכון.

843
00:46:20,770 --> 00:46:21,165
>> תלמיד: - עד -

844
00:46:21,165 --> 00:46:24,010
>> ג'ייסון הירשהורן: אז אני כמעט
חיובי שיעבוד.

845
00:46:24,010 --> 00:46:26,800
אבל הנקודה הוא, שאתה צריך שני
פיסות המידע כאן.

846
00:46:26,800 --> 00:46:30,050
אתה יכול לעשות את זה עם התחלה וסוף,
או שאתה יכול לעשות את זה עם גודל, ולאחר מכן

847
00:46:30,050 --> 00:46:31,060
כמה סמן.

848
00:46:31,060 --> 00:46:32,630
אבל אתה צריך לעשות שתי חתיכות
מידע כאן.

849
00:46:32,630 --> 00:46:34,160
אתה לא יכול להסתדר עם אחד בלבד.

850
00:46:34,160 --> 00:46:35,830
האם זה הגיוני?

851
00:46:35,830 --> 00:46:39,560
>> אז אנחנו הולכים לעבור, ו
אנחנו הולכים לעשות [לא ברורים]

852
00:46:39,560 --> 00:46:41,330
וליצור כמה סמנים.

853
00:46:41,330 --> 00:46:42,690
אז מה שאתה כותב בקוד שלך?

854
00:46:42,690 --> 00:46:46,190
>> תלמיד: אני רק אמרתי int הכפות
אחד שווה ל -0.

855
00:46:46,190 --> 00:46:47,790
>> ג'ייסון הירשהורן: בואו לקרוא
int זה, מתחיל.

856
00:46:47,790 --> 00:46:49,140
>> סטודנט: אישור.

857
00:46:49,140 --> 00:46:50,590
>> ג'ייסון הירשהורן: זה הופך את
יותר הגיוני בשבילי.

858
00:46:50,590 --> 00:46:51,670
ו?

859
00:46:51,670 --> 00:46:54,340
>> תלמיד: אני אמרתי, אני מניח, int מסתיים.

860
00:46:54,340 --> 00:46:55,870
>> ג'ייסון הירשהורן: int מסתיים.

861
00:46:55,870 --> 00:46:57,640
>> תלמיד: אני מניח, n מינוס 1,
או משהו כזה.

862
00:46:57,640 --> 00:46:59,100
כמו, האלמנט האחרון.

863
00:46:59,100 --> 00:47:02,310
>> ג'ייסון הירשהורן: אז אתה כתב, int
מתחיל שווה 0, פסיק, וint

864
00:47:02,310 --> 00:47:04,320
הסוף שווה n מינוס 1, פסיק.

865
00:47:04,320 --> 00:47:06,850
אז בעצם, מה שאנחנו עושים
כאן, 0 המיקום הראשון.

866
00:47:06,850 --> 00:47:09,570
וכמו שאנחנו יודעים במערכים, הם לא הולכים
עד n, הם הולכים עד n מינוס 1.

867
00:47:09,570 --> 00:47:11,110
אז יש לנו כמה גבולות של המערך שלנו.

868
00:47:11,110 --> 00:47:15,730
וגבולות אלה ראשוניים במקרה
הגבולות הראשוניים של הבעיה שלנו.

869
00:47:15,730 --> 00:47:16,640
על אישור.

870
00:47:16,640 --> 00:47:19,200
אז זה נשמע טוב.

871
00:47:19,200 --> 00:47:22,380
אז אם נחזור לקו הזה, ואילו
אורכה של הרשימה הוא גדול מ 0,

872
00:47:22,380 --> 00:47:24,752
מה, במקום n, צריך
אנחנו מכניסים לכאן?

873
00:47:24,752 --> 00:47:28,820
>> תלמיד: כתוב שהסתיים תחילת מינוס.

874
00:47:28,820 --> 00:47:34,780
>> ג'ייסון הירשהורן: בעוד שהסתיים במינוס
מתחיל הוא גדול מ 0?

875
00:47:34,780 --> 00:47:35,480
על אישור.

876
00:47:35,480 --> 00:47:37,730
ואנחנו יכולים, אם אנחנו רוצים
לעשות את זה קצת יותר נחמד, מה

877
00:47:37,730 --> 00:47:38,980
עוד אנחנו יכולים לעשות?

878
00:47:38,980 --> 00:47:41,650

879
00:47:41,650 --> 00:47:43,412
אם אנחנו רוצים לנקות
קוד זה קצת?

880
00:47:43,412 --> 00:47:46,716

881
00:47:46,716 --> 00:47:48,180
איך אנחנו יכולים להיפטר מ0?

882
00:47:48,180 --> 00:47:51,560

883
00:47:51,560 --> 00:47:52,690
זוהי רק שאלת סגנון.

884
00:47:52,690 --> 00:47:53,690
זה נכון עכשיו.

885
00:47:53,690 --> 00:47:54,870
>> תלמיד: Ending לא
תחילת שווה?

886
00:47:54,870 --> 00:47:55,740
>> ג'ייסון הירשהורן: אנחנו יכולים לעשות את מה?

887
00:47:55,740 --> 00:47:56,730
>> [קולות חציצה]

888
00:47:56,730 --> 00:47:57,330
>> סטודנט: סיום הוא גדול יותר?

889
00:47:57,330 --> 00:47:57,720
>> ג'ייסון הירשהורן: כן.

890
00:47:57,720 --> 00:48:01,110
אנחנו רק יכולים לעשות בזמן שהסתיים
גדול מהתחלה.

891
00:48:01,110 --> 00:48:03,580
נכון.

892
00:48:03,580 --> 00:48:06,240
הוספנו בתחילת לצד השני
על כך, ואנחנו נפטרנו מ0.

893
00:48:06,240 --> 00:48:08,000
אז זה פשוט נראה
מנקה קצת.

894
00:48:08,000 --> 00:48:08,990
על אישור.

895
00:48:08,990 --> 00:48:11,460
אז, בזמן שאורך הרשימה הוא 0, שכתבנו
כי בעוד שהסתיים הוא גדול יותר

896
00:48:11,460 --> 00:48:12,240
מהתחלה.

897
00:48:12,240 --> 00:48:19,840
אנחנו הולכים לשים בצורך שלנו
סוגריים מסולסלים, ואז הדבר הראשון

898
00:48:19,840 --> 00:48:22,090
אנחנו רוצים לעשות זה להסתכל על
אותם ברשימה קטנה.

899
00:48:22,090 --> 00:48:22,510
אתה?

900
00:48:22,510 --> 00:48:23,320
אתה יכול לתת לי -

901
00:48:23,320 --> 00:48:26,460
>> תלמיד: אם סוגריים
סוגר מרובע ערך -

902
00:48:26,460 --> 00:48:30,450
>> ג'ייסון הירשהורן: אם סוגריים
סוגר מרובע ערך.

903
00:48:30,450 --> 00:48:33,210
>> סטודנט: סיום חלקי 2.

904
00:48:33,210 --> 00:48:33,952
>> ג'ייסון הירשהורן: סיום?

905
00:48:33,952 --> 00:48:35,280
>> תלמיד: אני רואה בעיה עם שלך -

906
00:48:35,280 --> 00:48:35,750
>> ג'ייסון הירשהורן: אישור.

907
00:48:35,750 --> 00:48:39,150
ובכן, מסתכל על האמצע.

908
00:48:39,150 --> 00:48:41,226
איך אנחנו יודעים מה הוא אמצעי?

909
00:48:41,226 --> 00:48:42,450
כן.

910
00:48:42,450 --> 00:48:43,070
אז הרשה לי להסיר קוד זה.

911
00:48:43,070 --> 00:48:46,360
איך אנחנו יודעים מה הוא אמצעי?

912
00:48:46,360 --> 00:48:48,003
בכל דבר, כאשר יש לך ההתחלה
וסופו של הדבר, איך אתה מוצא

913
00:48:48,003 --> 00:48:48,876
האמצע?

914
00:48:48,876 --> 00:48:49,590
>> סטודנט: אתה בממוצע.

915
00:48:49,590 --> 00:48:51,820
>> סטודנט: אתה מוסיף אותם
ביחד ולאחר מכן -

916
00:48:51,820 --> 00:48:53,150
>> ג'ייסון הירשהורן: הוסף אותם
ביחד ולאחר מכן?

917
00:48:53,150 --> 00:48:54,090
>> תלמיד: ואתה בממוצע.

918
00:48:54,090 --> 00:48:55,050
לחלק אותו על ידי 2.

919
00:48:55,050 --> 00:48:56,500
>> ג'ייסון הירשהורן: הוסף אותם
יחד ומתחלקים על ידי 2.

920
00:48:56,500 --> 00:48:59,400
אז אמצע int שווה?

921
00:48:59,400 --> 00:49:01,120
טום, אתה יכול לתת לי את זה?

922
00:49:01,120 --> 00:49:03,550
>> תלמיד: החל מתוספת שהסתיים -

923
00:49:03,550 --> 00:49:04,950
>> ג'ייסון הירשהורן: התחלה
בתוספת שהסתיים.

924
00:49:04,950 --> 00:49:06,880
>> סטודנט: כל, סוגר, מחולק על ידי 2.

925
00:49:06,880 --> 00:49:10,940
>> ג'ייסון הירשהורן: כל, בסוגריים,
מחולק על ידי 2.

926
00:49:10,940 --> 00:49:16,300
אז זה נותן לי באמצע
על שום דבר, נכון?

927
00:49:16,300 --> 00:49:18,980
>> תלמיד: אתה גם צריך לאסוף אותו.

928
00:49:18,980 --> 00:49:19,990
>> ג'ייסון הירשהורן: מה אתה עושה
כלומר, אני צריך לאסוף אותו?

929
00:49:19,990 --> 00:49:20,400
>> [קולות חציצה]

930
00:49:20,400 --> 00:49:24,520
>> תלמיד: כי אם זה מוזר
מספר, אז זה כמו -

931
00:49:24,520 --> 00:49:25,440
>> ג'ייסון הירשהורן: טוב, בסדר.

932
00:49:25,440 --> 00:49:26,360
כדי שאוכל להשלים את זה.

933
00:49:26,360 --> 00:49:33,350
אבל אם זה מספר אי זוגי, 5, אני יכול
לוקח 1 מהאמצע.

934
00:49:33,350 --> 00:49:35,665
או אם זה מספר זוגי, ולא,
זה מקרה טוב יותר.

935
00:49:35,665 --> 00:49:39,600
אם זה 4, יש לנו 4 בלבד, אני יכול לקחת
"באמצע" הראשון, ציטוט, סוף ציטוט או

936
00:49:39,600 --> 00:49:41,760
אחד "באמצע". השני

937
00:49:41,760 --> 00:49:46,390
כך או יעבדו לחיפוש בינארי,
אז אני לא באמת צריך כדי להשלים את זה.

938
00:49:46,390 --> 00:49:48,640
אבל יש לי דבר אחד נוסף
צריך להסתכל על הקו הזה.

939
00:49:48,640 --> 00:49:50,530
אנחנו אולי לא מבינים את זה עדיין,
אבל אנחנו עוד נחזור לזה.

940
00:49:50,530 --> 00:49:53,200
בגלל הקו הזה למעשה עדיין
צריך עוד דבר אחד.

941
00:49:53,200 --> 00:49:55,990
>> אבל עד כה, שכתבנו
ארבע שורות של קוד.

942
00:49:55,990 --> 00:49:58,120
יש לנו ההתחלה שלנו
וכלה סמנים.

943
00:49:58,120 --> 00:50:01,320
יש לנו בזמן שהלולאה שלנו, הממפה
באופן ישיר לpseudocode שלנו.

944
00:50:01,320 --> 00:50:05,790
אנחנו מסתכלים על האמצע הממפה
ישירות על גבי pseudocode שלנו.

945
00:50:05,790 --> 00:50:09,070
הייתי אומר שזה הולך לאמצע
מהרשימה, הקו הזה של קוד.

946
00:50:09,070 --> 00:50:11,560
ואז, ברגע שאנחנו הולכים לאמצע
הרשימה, הדבר הבא שאנחנו צריכים לעשות

947
00:50:11,560 --> 00:50:14,880
הוא לבדוק אם הערך שלנו הוא שם בשביל
pseudocode שכתבנו קודם לכן.

948
00:50:14,880 --> 00:50:17,100
>> אז איך לבדוק אם הערך שלנו
הוא באמצע הרשימה?

949
00:50:17,100 --> 00:50:17,300
שלך.

950
00:50:17,300 --> 00:50:18,511
למה אתה לא עושה את זה?

951
00:50:18,511 --> 00:50:23,070
>> תלמיד: אם הערך שלנו הוא
באמצע הוא שווה

952
00:50:23,070 --> 00:50:24,592
כל מה שאנו קובעים -

953
00:50:24,592 --> 00:50:26,190
אני מתכוון שווה שווה ל -

954
00:50:26,190 --> 00:50:26,690
>> ג'ייסון הירשהורן: זה -

955
00:50:26,690 --> 00:50:27,940
על אישור.

956
00:50:27,940 --> 00:50:30,080

957
00:50:30,080 --> 00:50:32,170
>> תלמיד: אני לא בטוח מה
משתנה שאנחנו מחפשים

958
00:50:32,170 --> 00:50:32,850
לאם כי, הוא כי -

959
00:50:32,850 --> 00:50:33,330
>> [קולות חציצה]

960
00:50:33,330 --> 00:50:34,520
>> תלמיד: [לא ברור].

961
00:50:34,520 --> 00:50:35,060
>> ג'ייסון הירשהורן: בדיוק.

962
00:50:35,060 --> 00:50:37,260
להצהרה על הפונקציה,
אנחנו מחפשים ערך.

963
00:50:37,260 --> 00:50:39,760
אז אנחנו מחפשים את ערך
במערך של ערכים.

964
00:50:39,760 --> 00:50:41,080
אז אתה בדיוק נכון.

965
00:50:41,080 --> 00:50:45,040
אתה תעשה, אם סוגר ערך paren הפתוח
אמצע סגר שווים סוגר

966
00:50:45,040 --> 00:50:49,930
שווה ערך, ובפנים יש
מה אנחנו צריכים לעשות?

967
00:50:49,930 --> 00:50:51,230
אם הערך שלנו שם, מה
אנחנו צריכים לעשות?

968
00:50:51,230 --> 00:50:51,420
>> [קולות חציצה]

969
00:50:51,420 --> 00:50:52,160
>> סטודנטים: להחזיר אפס.

970
00:50:52,160 --> 00:50:53,070
>> ג'ייסון הירשהורן: החזר אמיתי.

971
00:50:53,070 --> 00:50:54,790
>> תלמיד: החזר אמיתי.

972
00:50:54,790 --> 00:50:57,856
>> ג'ייסון הירשהורן: מיכאל,
מה הקו הזה עושה?

973
00:50:57,856 --> 00:51:01,105
>> תלמיד: [לא ברור] את התכנית יש להפעיל
כמובן שלו, וכי הוא מעל, ו

974
00:51:01,105 --> 00:51:01,920
יש לך את מה שאתה צריך לעשות?

975
00:51:01,920 --> 00:51:03,030
>> ג'ייסון הירשהורן: התכנית או מה?

976
00:51:03,030 --> 00:51:03,700
במקרה זה?

977
00:51:03,700 --> 00:51:04,210
>> תלמיד: הפונקציה.

978
00:51:04,210 --> 00:51:05,170
>> ג'ייסון הירשהורן: הפונקציה.

979
00:51:05,170 --> 00:51:08,420
וכך, כדי לחזור לכל מה שנקרא
שלו ולתת לו הערך, אמיתי.

980
00:51:08,420 --> 00:51:09,890
בדיוק נכון.

981
00:51:09,890 --> 00:51:10,170
ראשי.

982
00:51:10,170 --> 00:51:12,035
מה סוג ההחזרה
מראשי, מייקל?

983
00:51:12,035 --> 00:51:16,480

984
00:51:16,480 --> 00:51:17,150
>> תלמיד: int, מספר שלם?

985
00:51:17,150 --> 00:51:18,080
>> ג'ייסון הירשהורן: int, בדיוק.

986
00:51:18,080 --> 00:51:18,680
מספר שלם.

987
00:51:18,680 --> 00:51:20,980
זה היה רק ​​שאלה לוודא
אתם כבר על גבי זה.

988
00:51:20,980 --> 00:51:24,250
מה זה בדרך כלל לחזור, אם
כל הדברים עובדים היטב?

989
00:51:24,250 --> 00:51:24,520
>> סטודנט: אפס.

990
00:51:24,520 --> 00:51:24,820
>> ג'ייסון הירשהורן: אפס.

991
00:51:24,820 --> 00:51:25,430
בדיוק נכון.

992
00:51:25,430 --> 00:51:28,790
>> תלמיד: אם זה פשוט מחזיר אמת,
אין שום מידע שניתנו

993
00:51:28,790 --> 00:51:30,675
על מה -

994
00:51:30,675 --> 00:51:34,040
אה, זה רק אומר שזה
הערך נמצא בתוך המערך.

995
00:51:34,040 --> 00:51:35,350
>> ג'ייסון הירשהורן: בדיוק.

996
00:51:35,350 --> 00:51:38,080
תכנית זו אינה נותנת מידע
היכן בדיוק הערך הוא.

997
00:51:38,080 --> 00:51:41,850
זה רק אומר, כן, מצאנו
את זה, או לא, אנחנו לא מוצאים אותו.

998
00:51:41,850 --> 00:51:42,990
אז אם מספר מצא, החזר אמיתי.

999
00:51:42,990 --> 00:51:45,500
טוב, בעצם אנחנו פשוט עשינו את זה באמת
במהירות עם ששורה אחת של קוד.

1000
00:51:45,500 --> 00:51:47,500
אז אני אעבור את הקו של pseudocode.

1001
00:51:47,500 --> 00:51:50,045
>> תלמיד: לא שאנחנו צריכים
כדי לשנות את המערך?

1002
00:51:50,045 --> 00:51:52,830
זה צריך להיות ערכים, ולא ערך, נכון?

1003
00:51:52,830 --> 00:51:53,430
>> ג'ייסון הירשהורן: מצטער.

1004
00:51:53,430 --> 00:51:54,010
תודה.

1005
00:51:54,010 --> 00:51:54,800
>> סטודנט: כן.

1006
00:51:54,800 --> 00:51:55,850
>> ג'ייסון הירשהורן: שורה זו
צריך להיות ערכים.

1007
00:51:55,850 --> 00:51:57,150
בדיוק נכון.

1008
00:51:57,150 --> 00:51:57,920
על אישור.

1009
00:51:57,920 --> 00:51:59,170
אז בדקנו את הרשימה באמצע.

1010
00:51:59,170 --> 00:52:00,790
אם תמורת מספר מצא נכון.

1011
00:52:00,790 --> 00:52:04,470
ממשיך הלאה עם pseudocode שלנו, אם
האמצע הוא גדול יותר, חיפוש מהשמאל.

1012
00:52:04,470 --> 00:52:09,640
אז היה לי בפה, אם מספר
גבוה יותר, חיפוש מהשמאל.

1013
00:52:09,640 --> 00:52:12,700

1014
00:52:12,700 --> 00:52:14,462
קונסטנטין, אתה יכול לתת
לי הקו הזה של קוד?

1015
00:52:14,462 --> 00:52:17,240

1016
00:52:17,240 --> 00:52:23,520
>> תלמיד: אם ערך של אמצע -

1017
00:52:23,520 --> 00:52:24,890
>> ג'ייסון הירשהורן: אז אם ערך -

1018
00:52:24,890 --> 00:52:28,890
אם paren הפתוח ערכי סוגר
סוגר קרוב אמצע -

1019
00:52:28,890 --> 00:52:31,500
>> סטודנט: האם קטן יותר מהערך?

1020
00:52:31,500 --> 00:52:32,760
>> ג'ייסון הירשהורן: האם פחות מ.

1021
00:52:32,760 --> 00:52:33,800
>> תלמיד: פחות מהערך.

1022
00:52:33,800 --> 00:52:34,060
>> ג'ייסון הירשהורן: ערך.

1023
00:52:34,060 --> 00:52:35,310
טוב, בעצם, אתה רוצה
לבדוק אם המספר -

1024
00:52:35,310 --> 00:52:38,310

1025
00:52:38,310 --> 00:52:38,490
סליחה.

1026
00:52:38,490 --> 00:52:39,140
זה קצת מבלבל.

1027
00:52:39,140 --> 00:52:43,920
אבל אחר אם המספר ב
אמצע הרשימה הוא גדול יותר.

1028
00:52:43,920 --> 00:52:45,170
>> תלמיד: אה, אוקיי.

1029
00:52:45,170 --> 00:52:49,800

1030
00:52:49,800 --> 00:52:50,410
>> ג'ייסון הירשהורן: אני תשנה את זה.

1031
00:52:50,410 --> 00:52:55,060
אחר אם האמצע הוא גבוה יותר, אנחנו
רוצה לחפש שמאל, בסדר?

1032
00:52:55,060 --> 00:52:57,310
ומה אנחנו עושים בתוך
זה אם מצב?

1033
00:52:57,310 --> 00:53:03,660

1034
00:53:03,660 --> 00:53:07,510
>> תלמיד: האם אני יכול לעשות שינוי קטן כדי
המצב, לשנות אותו אחר אם?

1035
00:53:07,510 --> 00:53:08,380
>> ג'ייסון הירשהורן: Else אם?

1036
00:53:08,380 --> 00:53:09,270
על אישור.

1037
00:53:09,270 --> 00:53:12,840
אז את הקוד הזה יהיה לבצע
בערך אותו הדבר.

1038
00:53:12,840 --> 00:53:18,620
אבל הדבר נחמד על שימוש אם, אחר
אם, אם, או אם אחר, אם אחר, אחר

1039
00:53:18,620 --> 00:53:22,320
משמעות הדבר היא כי רק אחד מאותם הוא הולך
להיבדק, לא כל שלושה מהם,

1040
00:53:22,320 --> 00:53:23,290
פוטנציאלי.

1041
00:53:23,290 --> 00:53:25,530
וזה עושה את זה קצת
יותר נחמד במחשב זה

1042
00:53:25,530 --> 00:53:26,670
הפעלת התכנית שלך.

1043
00:53:26,670 --> 00:53:27,620
>> אז [? קונסטנטין,?]

1044
00:53:27,620 --> 00:53:31,330
אנחנו בתוך הקו הזה, אחר אם ערכים,
סוגר קרוב באמצע מדרגת

1045
00:53:31,330 --> 00:53:32,260
גדול יותר מהערך.

1046
00:53:32,260 --> 00:53:33,150
מה אנחנו צריכים לעשות?

1047
00:53:33,150 --> 00:53:33,970
אנחנו צריכים לחפש בצד השמאל.

1048
00:53:33,970 --> 00:53:35,220
איך אנחנו עושים את זה?

1049
00:53:35,220 --> 00:53:46,960

1050
00:53:46,960 --> 00:53:48,720
אני הולך לתת לך התחלה.

1051
00:53:48,720 --> 00:53:52,210
>> יש לנו שני הדברים האלה בשם
מתחיל ומסתיים.

1052
00:53:52,210 --> 00:53:57,340
אז מה צריך לקרות
להתחלה?

1053
00:53:57,340 --> 00:53:59,640
אם ברצונך לחפש בצד השמאל של
רשימה, אנחנו מקבלים ההתחלה הנוכחית שלנו.

1054
00:53:59,640 --> 00:54:01,080
מה אנחנו צריכים לעשות את זה?

1055
00:54:01,080 --> 00:54:04,220
>> תלמיד: אנו קובעים את תחילת
לאמצע ועוד 1.

1056
00:54:04,220 --> 00:54:05,120
>> ג'ייסון הירשהורן: אז אם אנחנו
חיפוש בשמאל?

1057
00:54:05,120 --> 00:54:06,250
>> תלמיד: מצטער, מינוס באמצע -

1058
00:54:06,250 --> 00:54:11,310
כל כך את הסוף יהיה אמצע
מינוס 1 ותחילת -

1059
00:54:11,310 --> 00:54:12,450
>> ג'ייסון הירשהורן: ומה
קורה להתחלה?

1060
00:54:12,450 --> 00:54:13,210
>> תלמיד: הוא נשאר אותו הדבר.

1061
00:54:13,210 --> 00:54:14,120
>> ג'ייסון הירשהורן: אז
משמעות נשארת זהה.

1062
00:54:14,120 --> 00:54:16,040
אם אנחנו מחפשים שמאלי, אנחנו
תוך שימוש באותה ההתחלה -

1063
00:54:16,040 --> 00:54:16,860
בדיוק נכון.

1064
00:54:16,860 --> 00:54:17,870
ואת הסוף?

1065
00:54:17,870 --> 00:54:19,390
סליחה, מה עושה
סיום שווה שוב?

1066
00:54:19,390 --> 00:54:20,750
>> תלמיד: מינוס התיכון 1.

1067
00:54:20,750 --> 00:54:21,620
>> ג'ייסון הירשהורן: מינוס התיכון 1.

1068
00:54:21,620 --> 00:54:23,470
עכשיו, למה מינוס 1, ולא רק באמצע?

1069
00:54:23,470 --> 00:54:32,870

1070
00:54:32,870 --> 00:54:35,570
>> תלמיד: באמצע הוא מתוך
תמונה כבר, כי היו לנו

1071
00:54:35,570 --> 00:54:36,700
בדק שזה יצא?

1072
00:54:36,700 --> 00:54:37,630
>> ג'ייסון הירשהורן: זה
בדיוק נכון.

1073
00:54:37,630 --> 00:54:38,580
האמצע הוא מחוץ לתמונה.

1074
00:54:38,580 --> 00:54:39,800
אנחנו כבר בדקנו את האמצע.

1075
00:54:39,800 --> 00:54:44,730
אז אנחנו לא רוצים "האמצע", ציטוט
סוף ציטוט, כדי להמשיך להיות ב

1076
00:54:44,730 --> 00:54:46,110
מערך שאנחנו מחפשים.

1077
00:54:46,110 --> 00:54:47,670
אז זה פנטסטי.

1078
00:54:47,670 --> 00:54:50,670
>> אחר אם אמצע סוגר ערכים הוא גדול יותר
מהערך שהסתיים בשוויון

1079
00:54:50,670 --> 00:54:51,920
מינוס אמצע 1.

1080
00:54:51,920 --> 00:54:55,060

1081
00:54:55,060 --> 00:54:57,340
ג'ף, מה עם השורה האחרונה זה?

1082
00:54:57,340 --> 00:54:58,590
>> תלמיד: Else.

1083
00:54:58,590 --> 00:55:02,486

1084
00:55:02,486 --> 00:55:06,000
אמצע ערכים הוא פחות מהערך?

1085
00:55:06,000 --> 00:55:07,570
>> ג'ייסון הירשהורן: אנחנו
אתה נותן לי אחר.

1086
00:55:07,570 --> 00:55:09,310
אז אם אתה לא נותן לי -

1087
00:55:09,310 --> 00:55:12,270
>> תלמיד: אז מתחיל
יהיה בינונית בתוספת 1.

1088
00:55:12,270 --> 00:55:16,100

1089
00:55:16,100 --> 00:55:19,070
>> ג'ייסון הירשהורן: שווים החל
אמצע בתוספת 1, שוב, מאותה

1090
00:55:19,070 --> 00:55:20,820
הסיבה שקונסטנטינוס
נתן לנו קודם לכן.

1091
00:55:20,820 --> 00:55:24,280
ובסופו של הדבר, שלא נתן
שלי שורת קוד עדיין?

1092
00:55:24,280 --> 00:55:26,600
בתמורת שווא, שלמה ע"ה, מה
אנחנו כותבים כאן?

1093
00:55:26,600 --> 00:55:28,590
>> תלמיד: בתמורת שווא.

1094
00:55:28,590 --> 00:55:29,320
>> ג'ייסון הירשהורן: בתמורת שווא.

1095
00:55:29,320 --> 00:55:33,340
ואנחנו צריכים לעשות את זה, כי אם
לא מוצאים את זה, אנחנו צריכים לומר שאנחנו

1096
00:55:33,340 --> 00:55:34,080
לא מצא אותו.

1097
00:55:34,080 --> 00:55:36,270
ואנחנו אמרו שאנחנו הולכים לחזור
bool, אז בהחלט יש לנו לחזור

1098
00:55:36,270 --> 00:55:38,150
איפשהו bool.

1099
00:55:38,150 --> 00:55:42,590
>> אז בואו להפעיל את הקוד הזה.

1100
00:55:42,590 --> 00:55:44,520
בעצם אני הולך -

1101
00:55:44,520 --> 00:55:45,930
כך שאנחנו בטרמינל.

1102
00:55:45,930 --> 00:55:47,230
אנחנו לנקות את החלון שלנו.

1103
00:55:47,230 --> 00:55:49,270
בואו לעשות את כל.

1104
00:55:49,270 --> 00:55:50,340
מצאנו שיש טעות אחת.

1105
00:55:50,340 --> 00:55:54,280
יש שגיאה בשורת 15, צפוי
פסיק בסוף

1106
00:55:54,280 --> 00:55:54,890
הכרזה.

1107
00:55:54,890 --> 00:55:56,454
אז מה שעשיתי לשכוח?

1108
00:55:56,454 --> 00:55:57,230
>> תלמיד: נקודה ופסיק.

1109
00:55:57,230 --> 00:56:00,200
>> ג'ייסון הירשהורן: נקודה ופסיק
ממש עד כאן.

1110
00:56:00,200 --> 00:56:00,950
אני חושב שזה היה הקוד של טום.

1111
00:56:00,950 --> 00:56:01,870
אז טום, [לא ברור].

1112
00:56:01,870 --> 00:56:03,120
סתם, בצחוק.

1113
00:56:03,120 --> 00:56:05,010

1114
00:56:05,010 --> 00:56:07,310
בואו אל תעשו את כל זה שוב.

1115
00:56:07,310 --> 00:56:10,180
>> תלמיד: ספריית Dropbox מה
אנחנו צריכים להיות בזה?

1116
00:56:10,180 --> 00:56:11,345
>> ג'ייסון הירשהורן: אז אתה יכול
רק לצפות לזה קצת.

1117
00:56:11,345 --> 00:56:16,380
אבל שוב, אם אתה רוצה להעביר את זה
קוד לתוך ספריית pset3 לנסות

1118
00:56:16,380 --> 00:56:17,050
את זה, זה מה שאני עשיתי.

1119
00:56:17,050 --> 00:56:18,600
אם תשים לב כאן -
מצטער, שאלה טובה.

1120
00:56:18,600 --> 00:56:19,460
>> [? LS,?]

1121
00:56:19,460 --> 00:56:24,700
יש לי כאן את קוד find.c
מקוד ההפצה של השבוע.

1122
00:56:24,700 --> 00:56:26,300
יש לי helpers.h.

1123
00:56:26,300 --> 00:56:30,010
יש לי קובץ לעשות את זה אני ממש
ערך קצת כדי לכלול חדש אלה

1124
00:56:30,010 --> 00:56:30,710
קבצים שאנחנו כותבים.

1125
00:56:30,710 --> 00:56:34,120
כל קוד שיהיה זמין, לא
קוד ההפצה, אבל חדש

1126
00:56:34,120 --> 00:56:39,510
להפוך את הקובץ, יהיה קובץ helpers.h החדש
יהיה זמין באינטרנט להורדה.

1127
00:56:39,510 --> 00:56:41,800
שוב, אז אלה הם
קודים נוספים שיש לנו.

1128
00:56:41,800 --> 00:56:46,130
>> אז להפוך את הכל, בכל שורה זו, עושה למצוא,
בחירה בינארי, בועה - עושה

1129
00:56:46,130 --> 00:56:50,930
שלושתם ומכינים ל
למצוא את קוד הפעלה זו.

1130
00:56:50,930 --> 00:56:54,090
אז בדרך כלל, אנחנו לא רוצים
כדי ישר לcheck50.

1131
00:56:54,090 --> 00:56:57,580
אנחנו רוצים להריץ כמה בדיקות על שלנו.

1132
00:56:57,580 --> 00:57:11,750
אבל רק כדי שנוכל לזרז את זה קצת,
pset3.find 2013 check50 יעבור

1133
00:57:11,750 --> 00:57:14,630
בhelpers.c-- רע.

1134
00:57:14,630 --> 00:57:16,050
>> אין לי את זה עכשיו.

1135
00:57:16,050 --> 00:57:20,670
אז אנחנו בעצם הולכים
להפעיל את הקוד אמיתי.

1136
00:57:20,670 --> 00:57:23,570
Usage.find /, אתה יודע מה זה אומר?

1137
00:57:23,570 --> 00:57:25,970
>> סטודנט: אתה צריך שני
שורת הפקודה עליו.

1138
00:57:25,970 --> 00:57:26,980
>> ג'ייסון הירשהורן: אני צריך
שורת הפקודה שנייה.

1139
00:57:26,980 --> 00:57:30,640
ולפי המפרט, אני צריך
להיכנס למה שאנחנו מחפשים.

1140
00:57:30,640 --> 00:57:33,750
אז בואו נסתכל ל42.

1141
00:57:33,750 --> 00:57:37,030
אנחנו נשמור אותו במיון, כי אנחנו
לא כתב פונקציה מסוג עדיין -

1142
00:57:37,030 --> 00:57:41,830
42, 43, 44.

1143
00:57:41,830 --> 00:57:46,240
>> והבקרה D לא מצא
מחט בערימת השחת.

1144
00:57:46,240 --> 00:57:46,505
זה רע.

1145
00:57:46,505 --> 00:57:47,200
זה בהחלט שם.

1146
00:57:47,200 --> 00:57:48,090
בואו ננסה משהו אחר.

1147
00:57:48,090 --> 00:57:49,860
אולי זה בגלל שאני שם
זה בהתחלה.

1148
00:57:49,860 --> 00:57:54,490
>> בואו נעשה 41, 42, 43.

1149
00:57:54,490 --> 00:57:55,012
הנה.

1150
00:57:55,012 --> 00:57:56,400
הוא מצא אותו.

1151
00:57:56,400 --> 00:58:00,040
בואו תגידו את זה בסוף עכשיו, רק
כדי שנוכל להיות יסודי -

1152
00:58:00,040 --> 00:58:03,580
40, 41, 42.

1153
00:58:03,580 --> 00:58:05,760
לא מצא את המחט.

1154
00:58:05,760 --> 00:58:07,550
אז הזכרתי את זה קודם לכן.

1155
00:58:07,550 --> 00:58:08,980
לרוע המזל, ידעתי שזה
עומד לקרות.

1156
00:58:08,980 --> 00:58:11,490
>> אבל למטרות פדגוגיות,
זה טוב כדי לחקור אותו.

1157
00:58:11,490 --> 00:58:12,990
זה לא עובד.

1158
00:58:12,990 --> 00:58:16,020
מסיבה כלשהי, זה לא יכול למצוא אותו.

1159
00:58:16,020 --> 00:58:18,970
אנחנו יודעים מה יש שם, אבל
אנחנו לא מוצאים את זה.

1160
00:58:18,970 --> 00:58:24,140
אז דבר אחד שאנחנו יכולים לעשות הוא לעבור
GDB כדי למצוא אותו, אבל עושה לאף אחד,

1161
00:58:24,140 --> 00:58:27,850
מבלי לעבור דרך GDB, יש לי
תחושה של איפה אנחנו דפוקים?

1162
00:58:27,850 --> 00:58:28,480
[? Madu? ?]

1163
00:58:28,480 --> 00:58:30,960
>> תלמיד: אני חושב שזה יכול להיות כאשר מסתיים
שווה להתחלה, וזה

1164
00:58:30,960 --> 00:58:33,090
רק רשימה אחת אלמנט.

1165
00:58:33,090 --> 00:58:35,560
אז זה פשוט מתעלם ממנה במקום
של ממש בודק את זה.

1166
00:58:35,560 --> 00:58:36,940
>> ג'ייסון הירשהורן: זה
בדיוק נכון.

1167
00:58:36,940 --> 00:58:41,110
כאשר סיום שווה התחלה, אנחנו
עדיין יש אלמנט ברשימה שלנו?

1168
00:58:41,110 --> 00:58:42,480
>> סטודנט: כן.

1169
00:58:42,480 --> 00:58:45,450
>> ג'ייסון הירשהורן: כן, למעשה, אנחנו
יש אחד ורק אלמנט אחד.

1170
00:58:45,450 --> 00:58:50,500
ושסביר להניח שיקרה כאשר,
לקוד שבדקנו, אנחנו נמצאים ב

1171
00:58:50,500 --> 00:58:54,640
מול ערימת שחת או ב
סוף ערימת שחת.

1172
00:58:54,640 --> 00:58:56,000
זה מקום שבי התחלה ו
הסוף הוא הולך שווה

1173
00:58:56,000 --> 00:58:57,820
אחד, עם חיפוש בינארי.

1174
00:58:57,820 --> 00:59:01,440
אז בשני המקרים האלה זה לא עבד,
בגלל הסיום היה שווה להתחלה.

1175
00:59:01,440 --> 00:59:06,030
>> אבל אם מסתיימים שווה להתחלה,
אין תוך לולאה זו לבצע?

1176
00:59:06,030 --> 00:59:06,390
זה לא.

1177
00:59:06,390 --> 00:59:08,660
והיינו יכול לבדוק
ששוב דרך GDB.

1178
00:59:08,660 --> 00:59:14,000
אז איך אנחנו יכולים לתקן את הקוד הזה, כי
כאשר בזמן הסיום הוא שווה

1179
00:59:14,000 --> 00:59:16,070
מתחיל, אנחנו גם רוצים את זה
בעוד לולאה לרוץ.

1180
00:59:16,070 --> 00:59:18,620
>> אז מה תיקון שאנחנו יכולים לעשות בשורה 18?

1181
00:59:18,620 --> 00:59:21,060
>> תלמיד: [לא ברור] הוא גדול יותר
או שווה ל.

1182
00:59:21,060 --> 00:59:21,700
>> ג'ייסון הירשהורן: בדיוק נכון.

1183
00:59:21,700 --> 00:59:24,600
אמנם הסוף הוא גדול יותר מאשר
או שווה להתחלה.

1184
00:59:24,600 --> 00:59:27,300
אז עכשיו, אנו מקפידים לקבל את זה
מקרה פינה בסוף.

1185
00:59:27,300 --> 00:59:27,870
ובואו נראה.

1186
00:59:27,870 --> 00:59:29,560
בואו לרוץ עוד פעם אחת זה.

1187
00:59:29,560 --> 00:59:31,266
>> בואו נעשה את הכל.

1188
00:59:31,266 --> 00:59:33,910
שוב, יהיה לך רק
פעל יחד כאן.

1189
00:59:33,910 --> 00:59:36,280
מצא 41 הפעם.

1190
00:59:36,280 --> 00:59:37,360
רק לשמור את זה בקנה אחד.

1191
00:59:37,360 --> 00:59:38,210
>> מצא 42.

1192
00:59:38,210 --> 00:59:38,930
בואו תגידו את זה בהתחלה -

1193
00:59:38,930 --> 00:59:41,630
42, 43, 44.

1194
00:59:41,630 --> 00:59:42,860
אנחנו מצאנו אותו.

1195
00:59:42,860 --> 00:59:47,710
כך שאכן היה השינוי
אנחנו צריכים לעשות.

1196
00:59:47,710 --> 00:59:51,090
>> זה היה הרבה קידודנו
פשוט עשה את זה, חיפוש בינארי.

1197
00:59:51,090 --> 00:59:55,760
האם יש למישהו שאלות לפני
אני לעבור לשורות שכתבנו ב

1198
00:59:55,760 --> 00:59:58,750
חיפוש בינארי או איך שחשבנו
מה אנחנו לא להבין?

1199
00:59:58,750 --> 01:00:01,900

1200
01:00:01,900 --> 01:00:06,270
לפני שאנחנו עוברים, אני גם רוצה לציין
כי על פי רוב, אנו ממופים

1201
01:00:06,270 --> 01:00:09,300
פסאודו הקוד שלנו אחד ל
אחת על גבי הקוד שלנו.

1202
01:00:09,300 --> 01:00:11,550
>> הייתה לנו שדבר מסובך
כדי להבין עם

1203
01:00:11,550 --> 01:00:12,890
מתחיל ומסתיים.

1204
01:00:12,890 --> 01:00:17,380
אבל לא הבנת את זה, אתה
היה כותב די הרבה

1205
01:00:17,380 --> 01:00:20,740
קוד זהה, למעט
אלו שתי שורות העליונים.

1206
01:00:20,740 --> 01:00:23,380
ולאחר מכן היית הבין כש
אתה עשית את זה בבדיקות ומקרים ש

1207
01:00:23,380 --> 01:00:24,840
אתה צריך משהו אחר.

1208
01:00:24,840 --> 01:00:28,510
אז גם אם אתה הלכת אחרינו
שורה פסאודו קוד לשורה, היית לי

1209
01:00:28,510 --> 01:00:31,130
קיבל את כל אבל שתי שורות של
קוד שאתה צריך לכתוב.

1210
01:00:31,130 --> 01:00:33,900
>> ואני מוכן להתערב שאתם
היה כל הבין את זה

1211
01:00:33,900 --> 01:00:37,940
די מהר, כי אתה צריך לשים
איזשהו סמן לשם כדי להבין

1212
01:00:37,940 --> 01:00:39,190
איפה אתה היה.

1213
01:00:39,190 --> 01:00:41,540

1214
01:00:41,540 --> 01:00:44,550
כי שוב, הוא בכח של עשייה
פסאודו קוד מבעוד מועד.

1215
01:00:44,550 --> 01:00:47,310
אז אנחנו יכולים לעשות את ההיגיון ראשון, ולאחר מכן
אנחנו יכולים לדאוג לתחביר.

1216
01:00:47,310 --> 01:00:51,470
>> לו הייתי מבולבל לגבי ההיגיון
בעת שניסיתי לכתוב את הקוד הזה ב-C,

1217
01:00:51,470 --> 01:00:53,110
היינו מקבל את כל פישלתי.

1218
01:00:53,110 --> 01:00:56,340
ואז היינו שואל שאלות על
היגיון ותחביר והתמזגות

1219
01:00:56,340 --> 01:00:57,320
את כולם יחד.

1220
01:00:57,320 --> 01:01:02,170
ואנחנו היו מקבלים אבודים
במה שיכול להפוך במהירות

1221
01:01:02,170 --> 01:01:04,000
בעיה קשה מאוד.

1222
01:01:04,000 --> 01:01:08,680
אז בואו נעבור כעת
למיון בחירה.

1223
01:01:08,680 --> 01:01:10,760
>> יש לנו 20 דקות לסיום.

1224
01:01:10,760 --> 01:01:14,130
אז יש לי הרגשה שאנחנו לא יהיו מסוגלים
לעבור את כל מיון בחירה

1225
01:01:14,130 --> 01:01:15,940
ומיון בועות.

1226
01:01:15,940 --> 01:01:20,670
אבל תן לנו לפחות ניסיון
כדי לסיים את מיון בחירה.

1227
01:01:20,670 --> 01:01:23,540
אז ליישם באמצעות בחירת סוג
בעקבות הצהרה על פונקציה.

1228
01:01:23,540 --> 01:01:27,530
>> שוב, זה לקוח מתוך
בעיה להגדיר מפרט.

1229
01:01:27,530 --> 01:01:31,560
ערכי int הוא בסוגריים, הוא
מערך של מספרים שלמים.

1230
01:01:31,560 --> 01:01:33,490
וint.n הוא בגודל של מערך זה.

1231
01:01:33,490 --> 01:01:36,840
מיון בחירה הולך
למיין את המערך הזה.

1232
01:01:36,840 --> 01:01:43,580
>> אז למודל המנטלי שלנו של בחירה
סוג שהוא, אנחנו מושכים -

1233
01:01:43,580 --> 01:01:47,720
ראשון, אנו עוברים על הרשימה הראשונה
זמן, למצוא את המספר הקטן ביותר,

1234
01:01:47,720 --> 01:01:52,860
לשים אותו בהתחלה, למצוא השני
המספר הקטן ביותר, לשים אותו ב

1235
01:01:52,860 --> 01:01:56,380
עמדה שנייה, אם אנחנו רוצים
סוג בסדר עולה.

1236
01:01:56,380 --> 01:01:58,440
אני לא מכריח אותך לכתוב
פסאודו קוד עכשיו.

1237
01:01:58,440 --> 01:02:01,350
>> אבל לפני שאנחנו עושים את הקוד כתובענה ב
חמש דקות, אנחנו הולכים לכתוב

1238
01:02:01,350 --> 01:02:03,550
פסאודו קוד, כך שיש לנו איזו תחושה
של לאן אנחנו הולכים.

1239
01:02:03,550 --> 01:02:05,630
אז תנסה לכתוב פסאודו קוד
בעצמך.

1240
01:02:05,630 --> 01:02:08,610
ולאחר מכן תנסה להפוך את זה
פסאודו קוד לקוד.

1241
01:02:08,610 --> 01:02:10,740
אנחנו נעשה את זה כקבוצה
בחמש דקות.

1242
01:02:10,740 --> 01:02:32,560

1243
01:02:32,560 --> 01:02:33,895
>> וכמובן, תן לי לדעת אם
יש לך שאלות.

1244
01:02:33,895 --> 01:03:56,738

1245
01:03:56,738 --> 01:03:58,230
>> סטודנט: זה זה?

1246
01:03:58,230 --> 01:04:00,280
>> ג'ייסון הירשהורן: לראות כמה רחוק אתה
ניתן לקבל בשתי דקות נוספות.

1247
01:04:00,280 --> 01:04:01,790
אני מבין שאתה לא יהיה
תוכל לסיים.

1248
01:04:01,790 --> 01:04:03,050
אבל אנחנו נלך על זה כקבוצה.

1249
01:04:03,050 --> 01:04:57,830

1250
01:04:57,830 --> 01:05:00,630
>> אתה כל קידוד כל כך [לא ברור], ולכן אני
מצטער להשהות את מה שאתה עושה.

1251
01:05:00,630 --> 01:05:02,530
אבל בואו נעבור את זה כקבוצה.

1252
01:05:02,530 --> 01:05:07,590
ושוב, חיפוש בינארי, כל מה שאתה נותן
לי אחד לא אם יותר שורות קוד.

1253
01:05:07,590 --> 01:05:08,530
תודה לך על זה.

1254
01:05:08,530 --> 01:05:11,730
אנחנו הולכים לעשות את אותו הדבר
כאן, קוד יחד כקבוצה.

1255
01:05:11,730 --> 01:05:15,170
>> אז מיון בחירה - בואו נכתוב
כמה פסאודו קוד מהיר.

1256
01:05:15,170 --> 01:05:20,380
למודל המנטלי, מישהו יכול לתת לי
השורה הראשונה של פסאודו קוד, בבקשה?

1257
01:05:20,380 --> 01:05:23,000

1258
01:05:23,000 --> 01:05:24,270
מה אני רוצה לעשות?

1259
01:05:24,270 --> 01:05:27,070
>> תלמיד: בעוד הרשימה
הוא מקולקל.

1260
01:05:27,070 --> 01:05:30,630
>> ג'ייסון הירשהורן: על אישור, ואילו
הרשימה היא לא לפי סדר.

1261
01:05:30,630 --> 01:05:33,540
ומה זאת אומרת "מקולקל?"

1262
01:05:33,540 --> 01:05:34,960
>> תלמיד: בעוד [לא ברור]

1263
01:05:34,960 --> 01:05:36,210
לא עבר מיון.

1264
01:05:36,210 --> 01:05:38,460

1265
01:05:38,460 --> 01:05:40,290
>> ג'ייסון הירשהורן: בעוד הרשימה
הוא מקולקל, מה אנחנו עושים?

1266
01:05:40,290 --> 01:05:44,200
תן לי את השורה השנייה,
בבקשה, מרקוס.

1267
01:05:44,200 --> 01:05:47,186
>> תלמיד: אז למצוא הבא
המספר הקטן ביותר.

1268
01:05:47,186 --> 01:05:49,000
זה יהיה באופן מדורג.

1269
01:05:49,000 --> 01:05:55,140
>> ג'ייסון הירשהורן: אז למצוא את
ליד המספר הקטן ביותר.

1270
01:05:55,140 --> 01:05:56,460
ואז מישהו אחר?

1271
01:05:56,460 --> 01:06:01,030
ברגע שאנו מוצאים הבאים הקטנים ביותר
מספר, מה אנחנו עושים?

1272
01:06:01,030 --> 01:06:03,010
אני הולך לומר למצוא
המספר הקטן ביותר.

1273
01:06:03,010 --> 01:06:04,820
זה מה שאנחנו רוצים לעשות.

1274
01:06:04,820 --> 01:06:06,210
>> אז למצוא את המספר הקטן ביותר.

1275
01:06:06,210 --> 01:06:08,061
אז מה אנחנו עושים?

1276
01:06:08,061 --> 01:06:09,480
>> תלמיד: [לא ברור] להתחלה.

1277
01:06:09,480 --> 01:06:10,680
>> ג'ייסון הירשהורן: סליחה?

1278
01:06:10,680 --> 01:06:12,700
>> תלמיד: מניחים אותו ב
תחילתה של הרשימה.

1279
01:06:12,700 --> 01:06:18,540
>> ג'ייסון הירשהורן: אז למקם אותו ב
תחילתה של הרשימה.

1280
01:06:18,540 --> 01:06:20,140
ומה שאנחנו עושים את הדבר
זה היה בתחילת

1281
01:06:20,140 --> 01:06:20,830
של הרשימה, נכון?

1282
01:06:20,830 --> 01:06:21,910
אנחנו להחליף משהו.

1283
01:06:21,910 --> 01:06:23,130
אז איפה אנחנו שמים את זה?

1284
01:06:23,130 --> 01:06:24,120
כן, אנה?

1285
01:06:24,120 --> 01:06:25,520
>> תלמיד: איפה הכי קטן
מספר היה?

1286
01:06:25,520 --> 01:06:32,530
>> ג'ייסון הירשהורן: אז הכניס את תחילת
מהרשימה שבה

1287
01:06:32,530 --> 01:06:35,180
המספר הקטן ביותר היה.

1288
01:06:35,180 --> 01:06:38,510
אז בזמן שהרשימה היא לא לפי סדר, למצוא
המספר הקטן ביותר, למקם אותו

1289
01:06:38,510 --> 01:06:40,630
תחילתה של הרשימה, לשים את
תחילתה של הרשימה שבי

1290
01:06:40,630 --> 01:06:42,900
המספר הקטן ביותר היה.

1291
01:06:42,900 --> 01:06:45,780
מרקוס, אתה יכול לנסח מחדש את הקו הזה
בעוד שהרשימה היא מקולקל?

1292
01:06:45,780 --> 01:06:51,160

1293
01:06:51,160 --> 01:06:53,900
>> תלמיד: בעוד המספרים
לא היה מסודרים?

1294
01:06:53,900 --> 01:06:55,920
>> ג'ייסון הירשהורן: אוקיי, אז על מנת
יודע שהמספרים לא היו

1295
01:06:55,920 --> 01:06:58,670
מסודרים, מה אנחנו צריכים לעשות?

1296
01:06:58,670 --> 01:07:00,640
כמה אנחנו צריכים
לעבור את הרשימה הזאת?

1297
01:07:00,640 --> 01:07:09,650
>> תלמיד: אז אני מניח ללולאה, או
בזמן, ואילו מספרים שבדקו הוא פחות

1298
01:07:09,650 --> 01:07:11,900
מאורכה של הרשימה?

1299
01:07:11,900 --> 01:07:13,160
>> ג'ייסון הירשהורן: בסדר, זה טוב.

1300
01:07:13,160 --> 01:07:15,000
אני חושב שאני misphrased
השאלה שלי בצורה גרועה.

1301
01:07:15,000 --> 01:07:15,990
אני רק מנסה להגיע אל
אנחנו הולכים צריכים ללכת

1302
01:07:15,990 --> 01:07:17,580
באמצעות כל הרשימה.

1303
01:07:17,580 --> 01:07:20,490
אז בזמן שהרשימה היא לא לפי סדר,
בשבילי, קשה למפה הלאה.

1304
01:07:20,490 --> 01:07:24,940
אבל בעיקרון, ככה
אני חושב על זה.

1305
01:07:24,940 --> 01:07:28,880
לעבור את כל הרשימה, למצוא את
המספר הקטן ביותר, למקם אותו

1306
01:07:28,880 --> 01:07:30,130
מתחיל - למעשה, אתה צודק.

1307
01:07:30,130 --> 01:07:31,380
בואו נשים את שניהם.

1308
01:07:31,380 --> 01:07:33,470

1309
01:07:33,470 --> 01:07:39,050
>> אז בזמן שהרשימה היא לא לפי סדר, אנחנו
צריך לעבור את כל הרשימה

1310
01:07:39,050 --> 01:07:42,250
פעם אחת, למצוא את המספר, המקום הקטן ביותר
זה בתחילת הרשימה, לשים

1311
01:07:42,250 --> 01:07:45,430
תחילתה של הרשימה שבי
המספר הקטן ביותר היה, ואז אם

1312
01:07:45,430 --> 01:07:47,460
רשימה היא עדיין מקולקל, יש לנו
יש לעבור את זה

1313
01:07:47,460 --> 01:07:48,620
תהליך שוב, נכון?

1314
01:07:48,620 --> 01:07:51,610
בגלל זה מיון בחירה, ריצה Big-O
של מיון בחירה, מישהו?

1315
01:07:51,610 --> 01:07:52,830
>> תלמיד: n בריבוע.

1316
01:07:52,830 --> 01:07:53,590
>> ג'ייסון הירשהורן: n בריבוע.

1317
01:07:53,590 --> 01:07:57,040
כי כמו מרקוס ורק עכשיו הבינו
כאן, אנחנו הולכים צריכים

1318
01:07:57,040 --> 01:08:00,310
לעבור על רשימת הרשימה
מספר פעמים.

1319
01:08:00,310 --> 01:08:03,420
אז עובר משהו של
אורך n מספר הפעמים n

1320
01:08:03,420 --> 01:08:04,990
הוא למעשה ריבוע n.

1321
01:08:04,990 --> 01:08:08,100
>> אז זה pseudocode שלנו.

1322
01:08:08,100 --> 01:08:09,360
זה נראה טוב מאוד.

1323
01:08:09,360 --> 01:08:11,870
האם יש למישהו שאלות
על pseudocode?

1324
01:08:11,870 --> 01:08:14,440
משום שלמעשה מיון בחירה צריך
כנראה מגיע אחד לאחד, את קוד מ

1325
01:08:14,440 --> 01:08:14,980
pseudocode.

1326
01:08:14,980 --> 01:08:17,569
אז כל שאלות על
היגיון של pseudocode?

1327
01:08:17,569 --> 01:08:18,819
אנא שאל אותו כעת.

1328
01:08:18,819 --> 01:08:22,609

1329
01:08:22,609 --> 01:08:25,379
>> מיון בחירה - בעוד שהרשימה היא מתוך
של סדר, אנחנו הולכים לעבור את זה

1330
01:08:25,379 --> 01:08:27,529
ולמצוא את הכי קטנה בכל הפעם
ולשים אותו בחזית.

1331
01:08:27,529 --> 01:08:33,470
אז בזמן שהרשימה היא לא לפי סדר, יכול
מישהו נותן לי קו שקוד ש

1332
01:08:33,470 --> 01:08:39,689
לא נתן לי קו
של קוד עדיין, בבקשה?

1333
01:08:39,689 --> 01:08:40,939
זה נשמע כמו מה?

1334
01:08:40,939 --> 01:08:43,669

1335
01:08:43,669 --> 01:08:44,649
>> תלמיד: זה ללולאה.

1336
01:08:44,649 --> 01:08:45,830
>> ג'ייסון הירשהורן: זה נשמע
רוצה ללולאה.

1337
01:08:45,830 --> 01:08:47,653
אוקיי, אתה יכול לתת לי ללולאה?

1338
01:08:47,653 --> 01:08:48,925
ל--

1339
01:08:48,925 --> 01:08:50,219
>> תלמיד: אני שווה 0.

1340
01:08:50,219 --> 01:08:52,705
>> ג'ייסון הירשהורן: אני או -

1341
01:08:52,705 --> 01:08:55,111
מה חסר לנו?

1342
01:08:55,111 --> 01:08:56,819
מה הולך כאן?

1343
01:08:56,819 --> 01:08:57,550
>> תלמיד: Int.

1344
01:08:57,550 --> 01:08:59,270
>> ג'ייסון הירשהורן: בדיוק.

1345
01:08:59,270 --> 01:09:02,590
(אני int = 0; -

1346
01:09:02,590 --> 01:09:07,843
>> תלמיד: i <n: אני + +).

1347
01:09:07,843 --> 01:09:09,319
>> ג'ייסון הירשהורן: קטל אותו, ג'ף.

1348
01:09:09,319 --> 01:09:10,660
אנחנו הולכים ברשימה, נכון?

1349
01:09:10,660 --> 01:09:11,880
ראינו קוד שלפני כן.

1350
01:09:11,880 --> 01:09:12,850
מושלם.

1351
01:09:12,850 --> 01:09:14,790
אז בואו לשים הסוגריים המסולסלים שלנו כאן.

1352
01:09:14,790 --> 01:09:17,859
אני הולך לשים כמה
סוגריים מסולסלים כאן.

1353
01:09:17,859 --> 01:09:21,660
>> אז בזמן שהוא 0, אנחנו צריכים ללכת
דרך את הרשימה כולה.

1354
01:09:21,660 --> 01:09:26,612
אז בכל פעם שאנו עוברים את הרשימה,
מה שאנחנו רוצים לעקוב אחר?

1355
01:09:26,612 --> 01:09:28,260
>> תלמיד: אם כל חילופים הם עשו.

1356
01:09:28,260 --> 01:09:29,069
>> ג'ייסון הירשהורן: מצא
המספר הקטן ביותר.

1357
01:09:29,069 --> 01:09:31,479
אז אנחנו כנראה צריכים לעקוב אחר
המספר הקטן ביותר בכל פעם.

1358
01:09:31,479 --> 01:09:34,590
אז קו שאני יכול לעשות כדי לשמור על מסלול
של המספר הקטן ביותר?

1359
01:09:34,590 --> 01:09:37,720
שלמה ע"ה, איך אני יכול לשמור על
אחר משהו?

1360
01:09:37,720 --> 01:09:38,460
>> תלמיד: התחל משתנים חדש.

1361
01:09:38,460 --> 01:09:39,390
>> ג'ייסון הירשהורן: התחל משתנים חדש.

1362
01:09:39,390 --> 01:09:40,069
אז בואו ליצור משתנה.

1363
01:09:40,069 --> 01:09:41,830
איזה סוג?

1364
01:09:41,830 --> 01:09:42,930
>> תלמיד: Int.

1365
01:09:42,930 --> 01:09:43,710
>> ג'ייסון הירשהורן: Int.

1366
01:09:43,710 --> 01:09:44,939
בואו נקראים לזה הקטן ביותר.

1367
01:09:44,939 --> 01:09:47,600
ומה עושה את זה שווה כש
אנחנו רק בתחילת דרך?

1368
01:09:47,600 --> 01:09:48,910
יש לנו לא עברתי את הרשימה עדיין.

1369
01:09:48,910 --> 01:09:50,540
אנחנו בחלק הראשון של
רשימה בפעם הראשונה שלנו דרך.

1370
01:09:50,540 --> 01:09:51,930
מה זה שווה,
המספר הקטן ביותר?

1371
01:09:51,930 --> 01:09:54,140
>> סטודנט: ערכי i.

1372
01:09:54,140 --> 01:09:54,900
>> ג'ייסון הירשהורן: ערכי i.

1373
01:09:54,900 --> 01:09:56,980
זה נשמע בדיוק כמו שצריך, נכון?

1374
01:09:56,980 --> 01:09:59,590
המספר הקטן ביותר בתחילת
מקום שבו אנחנו נמצאים.

1375
01:09:59,590 --> 01:10:01,960
אז עכשיו יש לנו הקטן ביותר שלנו, ואנחנו צריכים
לעבור את כל הרשימה ו

1376
01:10:01,960 --> 01:10:05,080
להשוות את זה הקטן ביותר
לכל דבר אחר.

1377
01:10:05,080 --> 01:10:08,150
אז אנחנו עוברים על הרשימה שוב?

1378
01:10:08,150 --> 01:10:08,630
מייקל?

1379
01:10:08,630 --> 01:10:10,000
>> סטודנט: אתה צריך לעשות
נוסף ללולאה.

1380
01:10:10,000 --> 01:10:10,383
>> ג'ייסון הירשהורן: נוסף ללולאה.

1381
01:10:10,383 --> 01:10:11,276
בואו נעשה את זה.

1382
01:10:11,276 --> 01:10:12,540
תן לי קצת קוד.

1383
01:10:12,540 --> 01:10:13,790
>> תלמיד: ללולאה -

1384
01:10:13,790 --> 01:10:16,750

1385
01:10:16,750 --> 01:10:19,470
לקטן ביותר -

1386
01:10:19,470 --> 01:10:23,040

1387
01:10:23,040 --> 01:10:25,770
רק Int J, אתה יכול להגיד?

1388
01:10:25,770 --> 01:10:31,150
= 0; כזה ש--

1389
01:10:31,150 --> 01:10:34,014

1390
01:10:34,014 --> 01:10:35,710
>> ג'ייסון הירשהורן: ובכן, אם אנחנו רוצים
לעבור את כל הרשימה -

1391
01:10:35,710 --> 01:10:37,847
>> תלמיד: j <n, j + +).

1392
01:10:37,847 --> 01:10:42,140

1393
01:10:42,140 --> 01:10:42,405
>> ג'ייסון הירשהורן: מעולה.

1394
01:10:42,405 --> 01:10:46,100
אנחנו הולכים לעבור
ללולאה שוב.

1395
01:10:46,100 --> 01:10:51,380
ואיך אנחנו מוצאים
המספר הקטן ביותר?

1396
01:10:51,380 --> 01:10:52,630
טום?

1397
01:10:52,630 --> 01:10:54,570

1398
01:10:54,570 --> 01:11:00,520
יש לנו את המספר הקטן ביותר הנוכחי,
אז איך אנחנו מוצאים חדשים הקטנים ביותר?

1399
01:11:00,520 --> 01:11:07,200
>> תלמיד: אנחנו יכולים לבדוק אם הקטנים ביותר
יש לנו מספר גדול מ

1400
01:11:07,200 --> 01:11:09,040
ערכי j סוגר.

1401
01:11:09,040 --> 01:11:14,740
>> ג'ייסון הירשהורן: אז אם הקטן ביותר הוא
גדול מ j סוגר ערכים.

1402
01:11:14,740 --> 01:11:19,350
אז אם הנוכחי הקטן ביותר שלנו
גדול מ -

1403
01:11:19,350 --> 01:11:21,770
אני הולך להעביר את שני הקווים הללו
קוד שם בשביל שני.

1404
01:11:21,770 --> 01:11:26,010
כי לפני שאנחנו עושים בכל החלפה, אנחנו
צריך לעבור את כל הרשימה.

1405
01:11:26,010 --> 01:11:28,880
אז pseudocode זה בעצם צריך
להיות מחוץ שפנימי ללולאה.

1406
01:11:28,880 --> 01:11:30,390
אז לעבור את כל הרשימה.

1407
01:11:30,390 --> 01:11:34,520
אם הקטן ביותר הוא גדול יותר מאשר
j ערכים אז מה?

1408
01:11:34,520 --> 01:11:37,830
>> תלמיד: ואז הקטן ביותר
שווה j ערכים.

1409
01:11:37,830 --> 01:11:41,190

1410
01:11:41,190 --> 01:11:42,600
>> ג'ייסון הירשהורן: מעולה.

1411
01:11:42,600 --> 01:11:44,580
שאלה אחת מהירה -

1412
01:11:44,580 --> 01:11:47,236
הפעם הראשונה שאנחנו עוברים את זה לולאה,
אני הולך להיות שווה 0, j הולך

1413
01:11:47,236 --> 01:11:50,710
שווה 0 ברגע שנכנסנו לכאן.

1414
01:11:50,710 --> 01:11:52,410
אז אנחנו הולכים להיות השוואה
מספר לעצמו.

1415
01:11:52,410 --> 01:11:53,660
האם זה יעיל?

1416
01:11:53,660 --> 01:11:57,260

1417
01:11:57,260 --> 01:11:58,390
לא, זה לא ממש יעיל.

1418
01:11:58,390 --> 01:12:02,915
אז האם j שלנו צריך ללכת
מ -0 עד n בכל פעם?

1419
01:12:02,915 --> 01:12:06,310
האם אנו תמיד צריכים לבדוק
דרך את הרשימה כולה?

1420
01:12:06,310 --> 01:12:06,520
[לא ברור]?

1421
01:12:06,520 --> 01:12:07,564
>> תלמיד: התחל עם i במקום.

1422
01:12:07,564 --> 01:12:09,405
>> ג'ייסון הירשהורן: פחית j
להתחיל עם מה?

1423
01:12:09,405 --> 01:12:09,990
>> תלמיד: i.

1424
01:12:09,990 --> 01:12:13,040
>> ג'ייסון הירשהורן: j יכול להתחיל עם i.

1425
01:12:13,040 --> 01:12:18,840
אז עכשיו אנו משווים מתחילים
עם אחד אנחנו ב.

1426
01:12:18,840 --> 01:12:21,020
אבל אפילו אז, הוא שככל
יעיל ככל האפשר?

1427
01:12:21,020 --> 01:12:22,320
>> תלמיד: i + 1.

1428
01:12:22,320 --> 01:12:25,420
>> נראה אני + 1 להיות: ג'ייסון הירשהורן
היעילה ביותר, משום שאנו

1429
01:12:25,420 --> 01:12:26,120
כבר יש לי.

1430
01:12:26,120 --> 01:12:28,100
אנחנו לפיו כל
הקטן ביותר בשורה 15.

1431
01:12:28,100 --> 01:12:29,350
אנחנו הולכים להתחיל עם
הבא באופן אוטומטי.

1432
01:12:29,350 --> 01:12:34,470

1433
01:12:34,470 --> 01:12:38,540
אז אנחנו עוברים ללולאה.

1434
01:12:38,540 --> 01:12:39,620
נלך דרך כל זמן.

1435
01:12:39,620 --> 01:12:40,860
נלך דרך מספר הפעמים.

1436
01:12:40,860 --> 01:12:42,860
עכשיו אנחנו כבר gotten דרך
זה פנימי ללולאה.

1437
01:12:42,860 --> 01:12:44,350
יש לנו שומר את הערך הקטן ביותר.

1438
01:12:44,350 --> 01:12:46,045
אנחנו צריכים למקם אותו ב
תחילתה של הרשימה.

1439
01:12:46,045 --> 01:12:48,390
אז איך אני יכול למקם אותו ב
תחילתה של הרשימה?

1440
01:12:48,390 --> 01:12:51,290

1441
01:12:51,290 --> 01:12:55,926
מהו משתנה המתייחס
לתחילתה של הרשימה?

1442
01:12:55,926 --> 01:13:00,500
אנחנו בזה מחוץ ללולאה,
אז מה מתייחס

1443
01:13:00,500 --> 01:13:01,280
תחילתה של הרשימה?

1444
01:13:01,280 --> 01:13:02,880
>> סטודנט: ערכי i.

1445
01:13:02,880 --> 01:13:03,510
>> ג'ייסון הירשהורן: בדיוק נכון.

1446
01:13:03,510 --> 01:13:04,650
ערכים היא i תחילת -

1447
01:13:04,650 --> 01:13:06,320
או מצטער, לא בהתחלה.

1448
01:13:06,320 --> 01:13:07,090
זה היה מבלבל.

1449
01:13:07,090 --> 01:13:11,620
זה שבו אנו נמצאים בתחילתו של
החלק לא הממוין של הרשימה.

1450
01:13:11,620 --> 01:13:12,800
אז ערכים שאני.

1451
01:13:12,800 --> 01:13:14,050
ומה זה שווה?

1452
01:13:14,050 --> 01:13:15,925

1453
01:13:15,925 --> 01:13:17,326
>> תלמיד: הקטן ביותר.

1454
01:13:17,326 --> 01:13:18,862
>> ג'ייסון הירשהורן: ערכים שאני שווה מה?

1455
01:13:18,862 --> 01:13:19,310
>> תלמיד: הקטן ביותר.

1456
01:13:19,310 --> 01:13:20,030
>> ג'ייסון הירשהורן: הקטן ביותר.

1457
01:13:20,030 --> 01:13:20,980
בדיוק נכון.

1458
01:13:20,980 --> 01:13:23,510
אז אנחנו מניחים אותה בתחילת
מהרשימה, ועכשיו אנחנו צריכים לשים

1459
01:13:23,510 --> 01:13:25,710
תחילתה של הרשימה שבי
המספר הקטן ביותר היה.

1460
01:13:25,710 --> 01:13:29,700
אז איך אני יכול לכתוב בו
המספר הקטן ביותר היה?

1461
01:13:29,700 --> 01:13:31,670
ערכים של מה?

1462
01:13:31,670 --> 01:13:33,170
>> תלמיד: 0.

1463
01:13:33,170 --> 01:13:34,090
>> ג'ייסון הירשהורן: קטן
מספר זה על 0?

1464
01:13:34,090 --> 01:13:35,340
>> סטודנט: כן.

1465
01:13:35,340 --> 01:13:38,680

1466
01:13:38,680 --> 01:13:39,910
>> ג'ייסון הירשהורן: מה אם הקטן ביותר
מספר היה בסוף

1467
01:13:39,910 --> 01:13:40,860
רשימה לא ממוינת זה?

1468
01:13:40,860 --> 01:13:42,460
>> סטודנט: סליחה, מה הייתה השאלה?

1469
01:13:42,460 --> 01:13:44,020
>> ג'ייסון הירשהורן: איפה הוא
המספר הקטן ביותר?

1470
01:13:44,020 --> 01:13:46,940
לקחנו את הכי קטן ולשים אותו ב
מתחיל, עם קו זה ממש כאן.

1471
01:13:46,940 --> 01:13:48,987
>> תלמיד: זה צריך להיות
אוחסן בכמה -

1472
01:13:48,987 --> 01:13:50,510
>> סטודנט: ערכי j.

1473
01:13:50,510 --> 01:13:51,520
>> ג'ייסון הירשהורן: ובכן, זה
לא בהכרח ערכי j.

1474
01:13:51,520 --> 01:13:54,100
זה אפילו לא קיים בשלב זה.

1475
01:13:54,100 --> 01:13:55,960
>> סטודנט: אתה צריך להצהיר על
משתנה מוקדם ו

1476
01:13:55,960 --> 01:13:58,230
לאחר מכן להקצות אותו -

1477
01:13:58,230 --> 01:14:01,150
כאשר אתה מוצא את המספר הקטן ביותר,
להקצות את המדד של מספר שכדי

1478
01:14:01,150 --> 01:14:02,480
כמה משתנים או משהו כזה.

1479
01:14:02,480 --> 01:14:04,790
>> ג'ייסון הירשהורן: אז יכול
אתה אומר את זה שוב?

1480
01:14:04,790 --> 01:14:08,390
>> תלמיד: אז איפה אתה הכריז int
הקטן ביותר, אתה צריך גם להצהיר על int

1481
01:14:08,390 --> 01:14:10,750
המדד הקטן ביותר = i, או
משהו כזה.

1482
01:14:10,750 --> 01:14:13,280
>> ג'ייסון הירשהורן: אז איפה אני int
הקטן ביותר, אני צריך לעקוב לא רק

1483
01:14:13,280 --> 01:14:16,150
של הערך אלא המיקום.

1484
01:14:16,150 --> 01:14:20,850
int smallest_location = בזה
מקרה, אנחנו פשוט עושים לי.

1485
01:14:20,850 --> 01:14:22,390
אנחנו צריכים לדעת איפה זה.

1486
01:14:22,390 --> 01:14:26,820
יש לנו בסופו של הקוד, ואנחנו
הבנתי שיש לנו מושג איפה הוא.

1487
01:14:26,820 --> 01:14:29,810
וכך שוב, אנחנו מיפוי
זה על אחד לאחד.

1488
01:14:29,810 --> 01:14:32,890
אתם קידוד זה ברצון שלך
כנראה להגיע לאותה הבעיה.

1489
01:14:32,890 --> 01:14:34,130
איך לעזאזל אני מוצא אותו?

1490
01:14:34,130 --> 01:14:36,720
ואז אתה מבין, חכה, אני
צריך לעקוב אחר זה.

1491
01:14:36,720 --> 01:14:38,500
>> אז אם הקטן ביותר הוא גדול יותר
מ י ערכים.

1492
01:14:38,500 --> 01:14:39,740
אנו קובעים קטן שווים ל j ערכים.

1493
01:14:39,740 --> 01:14:42,090
מה עוד אנחנו צריכים לשנות?

1494
01:14:42,090 --> 01:14:43,710
קונסטנטין, מה עוד לעשות
אנחנו צריכים לשנות?

1495
01:14:43,710 --> 01:14:44,560
>> תלמיד: המיקום.

1496
01:14:44,560 --> 01:14:45,270
>> ג'ייסון הירשהורן: בדיוק.

1497
01:14:45,270 --> 01:14:46,925
אז תן לי את השורה הזאת בקוד.

1498
01:14:46,925 --> 01:14:53,310
>> תלמיד: smallest_location = j.

1499
01:14:53,310 --> 01:14:54,790
>> ג'ייסון הירשהורן: בדיוק.

1500
01:14:54,790 --> 01:14:58,210
ולאחר מכן נחלש בסוף, אם אנחנו רוצים
לשים את תחילתה של הרשימה שבי

1501
01:14:58,210 --> 01:15:00,790
המספר הקטן ביותר היה, איך
אין אנו מתייחסים למקום שבי

1502
01:15:00,790 --> 01:15:02,200
המספר הקטן ביותר היה?

1503
01:15:02,200 --> 01:15:03,580
מרקוס?

1504
01:15:03,580 --> 01:15:08,530
>> תלמיד: המספר הקטן ביותר היה
ממוקם במיקום הקטן ביותר.

1505
01:15:08,530 --> 01:15:12,230
>> ג'ייסון הירשהורן: אז בערכים
smallest_location.

1506
01:15:12,230 --> 01:15:14,700
ומה שאנחנו יכולים לשים שם?

1507
01:15:14,700 --> 01:15:17,600
תחילת
רשימה, מה זה?

1508
01:15:17,600 --> 01:15:19,710
>> תלמיד: טוב, אנחנו לא באמת יודעים
יותר בגלל שאנחנו החלפנו את.

1509
01:15:19,710 --> 01:15:23,250
אז זה במקומות החליפו
משני הקווים האלה?

1510
01:15:23,250 --> 01:15:26,110
אם תעבור את שני הקווים האלה מסביב.

1511
01:15:26,110 --> 01:15:30,740
>> ג'ייסון הירשהורן: אוקיי, אז אנחנו לא
יותר, כי יש לנו לאפס את השורה

1512
01:15:30,740 --> 01:15:31,960
לפני ערכי i לקטנה ביותר.

1513
01:15:31,960 --> 01:15:33,810
אז הפסדנו כי ערך ראשוני.

1514
01:15:33,810 --> 01:15:37,350
אז אתה אמר החלפת שתי שורות אלה.

1515
01:15:37,350 --> 01:15:41,780
אז עכשיו לשים את תחילתה של הרשימה
שבו המספר הקטן ביותר היה.

1516
01:15:41,780 --> 01:15:47,060
אז smallest_location שווה ערכי i.

1517
01:15:47,060 --> 01:15:51,310
זה שזז תחילת
חלק לא ממוין של הרשימה כדי

1518
01:15:51,310 --> 01:15:52,090
המיקום הקטן ביותר.

1519
01:15:52,090 --> 01:15:54,860
ולאחר מכן לערכים i אנו נעים
שהמספר הקטן ביותר.

1520
01:15:54,860 --> 01:15:57,450
>> האם זה הגיוני למה שאנו
נאלץ לבצע החלפה ש?

1521
01:15:57,450 --> 01:15:59,650
היינו מוחלף ערך ש--
עוד דבר שכנראה יש לך

1522
01:15:59,650 --> 01:16:02,740
הבין ומצאו בתוצר.

1523
01:16:02,740 --> 01:16:05,310
אז יש לנו לטפל בן
כל pseudocode.

1524
01:16:05,310 --> 01:16:10,935
האם יש עוד משהו שאנחנו
צריך לכתוב כאן?

1525
01:16:10,935 --> 01:16:14,911
מישהו יכול לחשוב על שום דבר?

1526
01:16:14,911 --> 01:16:16,180
>> תלמיד: איך אתה יודע
כשתסיים?

1527
01:16:16,180 --> 01:16:17,680
>> ג'ייסון הירשהורן: איך אנחנו
יודעים מתי תסיים?

1528
01:16:17,680 --> 01:16:18,890
שאלה גדולה.

1529
01:16:18,890 --> 01:16:21,684
אז איך אנחנו יודעים מתי אנחנו סיימנו.

1530
01:16:21,684 --> 01:16:24,720
>> סטודנט: יצירה משתנה כדי לשמור על ספירה
של אם יש החלפה שנעשתה או לא

1531
01:16:24,720 --> 01:16:27,810
ולעבור את מעבר.

1532
01:16:27,810 --> 01:16:30,180
>> ג'ייסון הירשהורן: אישור.

1533
01:16:30,180 --> 01:16:31,800
שיעבוד במיון בועות.

1534
01:16:31,800 --> 01:16:35,210
אבל למיון בחירה, אם אנחנו לא
לעשות החלפה, שיכול להיות רק

1535
01:16:35,210 --> 01:16:38,670
בגלל הערך הקטן ביותר הוא
בזה המיקום הנכון שלה.

1536
01:16:38,670 --> 01:16:41,240
אולי יש לנו רשימה 1, 2, 4, 3.

1537
01:16:41,240 --> 01:16:42,830
הפעם השנייה דרכנו
לא יעשה כל חילופים.

1538
01:16:42,830 --> 01:16:47,260
נהיה על המספר 2, אבל אנחנו
עדיין צריכים להמשיך.

1539
01:16:47,260 --> 01:16:49,390
אז אנחנו צריכים לעשות כדי לעקוב אחר כאשר
שנסיים, או שאנחנו פשוט רוצים ללכת

1540
01:16:49,390 --> 01:16:50,640
עד שזה נגמר?

1541
01:16:50,640 --> 01:16:54,098

1542
01:16:54,098 --> 01:16:56,740
>> תלמיד: אנחנו יכולים פשוט ללכת
עד שזה נגמר.

1543
01:16:56,740 --> 01:16:58,090
>> ג'ייסון הירשהורן: אנחנו יכולים רק
ללכת עד שזה נגמר.

1544
01:16:58,090 --> 01:17:01,720
במיון בועות, אתה בדיוק נכון,
ג'ף ושלמה ע"ה, עם הפתרון שלך -

1545
01:17:01,720 --> 01:17:04,990
זה נהדר כדי לעקוב אחר כמה
חילופים שבצעת, משום שבבועה

1546
01:17:04,990 --> 01:17:07,920
סוג שהוא, אם אתה עושה למעשה לא עושה שום עסקות החלף,
תסיים ואולי אתה יכול לחתוך שלך

1547
01:17:07,920 --> 01:17:09,000
בעיה קצת למטה.

1548
01:17:09,000 --> 01:17:11,440
אבל למיון בחירה, יש לך באמת
יש לעבור לסוף

1549
01:17:11,440 --> 01:17:14,940
רשימה כל זמן בסביבה.

1550
01:17:14,940 --> 01:17:16,200
>> אז זה זה.

1551
01:17:16,200 --> 01:17:18,530
יש לנו שתי דקות לסיום.

1552
01:17:18,530 --> 01:17:21,560
בואו נעשה את הכל.

1553
01:17:21,560 --> 01:17:24,340
תן לי רק פתוח מצא כאן ולעשות
בטוח שאני למעשה קורא את -

1554
01:17:24,340 --> 01:17:25,610
אני לא קורא מיון בועות.

1555
01:17:25,610 --> 01:17:29,230
בואו תשנה את זה למיון בחירה.

1556
01:17:29,230 --> 01:17:31,060
לעשות את כל. / למצוא.

1557
01:17:31,060 --> 01:17:32,360
בואו למצוא 42.

1558
01:17:32,360 --> 01:17:38,110
הפעם אנחנו הולכים לעבור
רשימה לא ממוינת, משום שהוא צריך למיין

1559
01:17:38,110 --> 01:17:43,790
הראשון, לקוד למצוא - צריך למיין
באמצעות הפונקציה ראשונה מהסוג שלנו ולאחר מכן

1560
01:17:43,790 --> 01:17:44,995
לחפש משהו.

1561
01:17:44,995 --> 01:17:46,245
אני מחזיק אצבעות לכולם.

1562
01:17:46,245 --> 01:17:48,530

1563
01:17:48,530 --> 01:17:49,370
>> אלוהים אדירים.

1564
01:17:49,370 --> 01:17:50,800
וואו, הלב שלי דפק.

1565
01:17:50,800 --> 01:17:52,320
אז זה נכון.

1566
01:17:52,320 --> 01:17:57,270
למעשה, אם רצנו את זה יותר
בהרחבה, את הקוד, עד כמה שאני יכול

1567
01:17:57,270 --> 01:17:59,280
תגיד, זה נכון באופן מושלם.

1568
01:17:59,280 --> 01:18:02,150
יש כמה הצעות
שיהיה לי בשבילך.

1569
01:18:02,150 --> 01:18:06,215
לדוגמא, 15 ו16 נראים
מיותר קצת.

1570
01:18:06,215 --> 01:18:09,450
זה נראה כאילו אתה לא בהכרח
צריך להציל את שני אלה.

1571
01:18:09,450 --> 01:18:12,790
אם יש לך את מיקומו הקטן ביותר, אתה
בקלות יכול למצוא את הערך הקטן ביותר על ידי

1572
01:18:12,790 --> 01:18:14,750
פשוט להקליד ערכים של i.

1573
01:18:14,750 --> 01:18:18,100
>> אז אם אני היה אמור לדירוג הקוד שלך,
שבו אני יהיה למעשה, הייתי

1574
01:18:18,100 --> 01:18:21,160
כנראה לקחת את נקודה אם אתה
כלל שני אלה, כי אתה

1575
01:18:21,160 --> 01:18:22,670
לא צריך את שני אלה.

1576
01:18:22,670 --> 01:18:25,400
אם יש לך את המיקום, אתה יכול
מאוד בקלות לקבל את התמורה.

1577
01:18:25,400 --> 01:18:27,520
וזה נראה קצת מוזר
כדי לאחסן את שניהם.

1578
01:18:27,520 --> 01:18:31,070
אולי אפילו לא לקחת נקודה, אבל
בהחלט להגיב שזה אולי

1579
01:18:31,070 --> 01:18:32,670
לא בחירה סגנונית
אתה צריך לעשות.

1580
01:18:32,670 --> 01:18:35,290
כמובן, הקוד עדיין
פועל היטב.

1581
01:18:35,290 --> 01:18:36,860
>> אז לצערנו אנחנו לא
להגיע למיון בועות.

1582
01:18:36,860 --> 01:18:37,940
אני מצטער על זה.

1583
01:18:37,940 --> 01:18:39,135
עשינו את מיון בחירת גימור.

1584
01:18:39,135 --> 01:18:41,450
האם יש למישהו שאלות סופיות
על מיון בחירה?

1585
01:18:41,450 --> 01:18:44,320

1586
01:18:44,320 --> 01:18:47,690
>> אוקיי, לפני שאנחנו יוצאים, אני רוצה אותך
כדי לפתוח את דפדפן Chrome שלך.

1587
01:18:47,690 --> 01:18:54,340
סליחה, זה היה רק ​​תקע בוטה
לסוג אחד של דפדפן אינטרנט.

1588
01:18:54,340 --> 01:18:57,770
אתה יכול לפתוח כל סוג של דפדפן,
אבל זה בטח אהיה Chrome.

1589
01:18:57,770 --> 01:19:01,250
וללכת לאתר זה הבא -

1590
01:19:01,250 --> 01:19:06,410
sayat.me/cs50.

1591
01:19:06,410 --> 01:19:07,685
אם אתה לא מקליד במחשב שלך
עכשיו, אתה באופן ברור

1592
01:19:07,685 --> 01:19:10,210
לא עושה את זה, טום.

1593
01:19:10,210 --> 01:19:12,870
>> ובבקשה תעשה את זה גם נכון
עכשיו או בשעה הבאה -

1594
01:19:12,870 --> 01:19:14,260
תן לי קצת משוב.

1595
01:19:14,260 --> 01:19:15,660
זה רק סעיף שניים.

1596
01:19:15,660 --> 01:19:18,060
יש לנו הרבה יותר ביחד, ולכן אני
יש הרבה מקום לשיפור.

1597
01:19:18,060 --> 01:19:19,620
אני מקווה שגם עשיתי כמה דברים טובים.

1598
01:19:19,620 --> 01:19:22,160
אז אתה יכול לגרום לי להרגיש כל רע, אבל אם
אתה רוצה גם לתת לי סמיילי

1599
01:19:22,160 --> 01:19:24,250
פנים, אני אעריך את זה גם.

1600
01:19:24,250 --> 01:19:25,330
מלא שבי

1601
01:19:25,330 --> 01:19:28,210
>> ועם דקה אחת שמאלה,
זה היה שבוע שלושה.

1602
01:19:28,210 --> 01:19:30,750
אני אעמוד מחוץ לקצת
אם יש לך שאלות.

1603
01:19:30,750 --> 01:19:32,220
אני אראה לך חבר 'ה ב
להרצות מחר.

1604
01:19:32,220 --> 01:19:34,742