1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [סעיף 3] [פחות נוח]

2
00:00:03,000 --> 00:00:05,000
>> [נייט Hardison] [אוניברסיטת הרווארד]

3
00:00:05,000 --> 00:00:08,000
>> [זה CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> בסדר, בואו נתחיל.

5
00:00:10,000 --> 00:00:13,000
ברוכים הבאים לשבוע 4 של CS50.

6
00:00:13,000 --> 00:00:19,000
אם אתם פותחים את דפדפן אינטרנט ולפתוח 3 pset,

7
00:00:19,000 --> 00:00:23,000
מירוץ עם CS50, אנחנו מתכוונים להתחיל ללכת

8
00:00:23,000 --> 00:00:26,000
דרך הסעיף של שאלות שם.

9
00:00:26,000 --> 00:00:32,000
בדיוק כמו בשבוע שעבר, אנו נפעל בCS50 Spaces,

10
00:00:32,000 --> 00:00:35,000
אם אתה גם למשוך את זה עד, כמו גם,

11
00:00:35,000 --> 00:00:43,000
ואם אתה הולך קדימה ובקר בקישור זה שיש לי כאן למעלה בראש.

12
00:00:43,000 --> 00:00:45,000
זה זמן להתחיל לעבוד.

13
00:00:45,000 --> 00:00:51,000
יש לנו תכנית ההיי הקטנה שלנו כאן. לא בצורה מטורפת.

14
00:00:51,000 --> 00:00:55,000
אחד הדברים הראשונים שאני רוצה לעשות איתכם היום הוא לעבור על כמה פתרונות

15
00:00:55,000 --> 00:00:58,000
על ערכת בעיה 1, סוג של פתרונות לדוגמה,

16
00:00:58,000 --> 00:01:03,000
רק אז אתה יכול לקבל תחושה של איזה סוג של צוות הקוד כותב,

17
00:01:03,000 --> 00:01:07,000
אילו סוגים של תלמידי קוד אחרים כותבים,

18
00:01:07,000 --> 00:01:10,000
ויש לך תסתכל על זה, כי אני יודע שזה מוזר

19
00:01:10,000 --> 00:01:14,000
כשאתה מגיש פתרון לבעיה ולקבל סט הערות

20
00:01:14,000 --> 00:01:18,000
בגרסה שלך, אבל לפעמים זה מועיל כדי לראות איך אנשים אחרים עשו את זה,

21
00:01:18,000 --> 00:01:22,000
במיוחד אלה שאינם נחמדים למראה.

22
00:01:22,000 --> 00:01:27,000
על פי רוב, אני מאוד התרשמתי מהפתרונים שאתם יצרתם.

23
00:01:27,000 --> 00:01:31,000
אני עדיין לא התחלתי להסתכל 2s הגדרת הבעיה שלך, אבל אם הם כל דבר כמו הראשון,

24
00:01:31,000 --> 00:01:34,000
זה אומר רק דברים טובים.

25
00:01:34,000 --> 00:01:40,000
>> אם אתה מסתכל על התיקונים שלי, בואו נתחיל את כל הדרך למטה ליום 1 בגרסות,

26
00:01:40,000 --> 00:01:47,000
ואנחנו הולכים לקחת מבט מהיר על פתרון מריו.

27
00:01:47,000 --> 00:01:54,000
אם אתה מושך את זה, תוכניות אלה שאנחנו הולכים להציג הן נכונות.

28
00:01:54,000 --> 00:01:56,000
לא היו בעיות עם תקינות בעיות אלה, אלא,

29
00:01:56,000 --> 00:01:59,000
אנחנו רוצים לדבר קצת על נושאי העיצוב השונים

30
00:01:59,000 --> 00:02:03,000
שהיו בשימוש כאן.

31
00:02:03,000 --> 00:02:08,000
אחד הדברים שהיו מעניין לגבי הפתרון

32
00:02:08,000 --> 00:02:11,000
הוא שהוא משמש המבנה החדש הזה שנקרא ק"ג להגדיר,

33
00:02:11,000 --> 00:02:15,000
לפעמים גם מכונה חשיש להגדיר.

34
00:02:15,000 --> 00:02:18,000
בואו להתקרב על זה כאן.

35
00:02:18,000 --> 00:02:24,000
# Define מאפשר לך לתת שמות למספרים הללו בתכנית שלך.

36
00:02:24,000 --> 00:02:28,000
במקרה זה, בגובה המרבי של פירמידה במריו

37
00:02:28,000 --> 00:02:34,000
היה 23 ולא לשים 23 בקוד שלי,

38
00:02:34,000 --> 00:02:37,000
היינו מתייחס לזה כקשה 23 קידוד -

39
00:02:37,000 --> 00:02:43,000
במקום זה נותן את השם MAX_HEIGHT למספר זה,

40
00:02:43,000 --> 00:02:48,000
כך שכאן בעשה תוך לולאתי

41
00:02:48,000 --> 00:02:51,000
אתה באמת יכול להתייחס לMAX_HEIGHT

42
00:02:51,000 --> 00:02:55,000
במקום לשים את המספר 23 פנימה

43
00:02:55,000 --> 00:02:57,000
[סטודנטים] מה היתרון של עושה את זה?

44
00:02:57,000 --> 00:02:59,000
זו שאלה גדולה.

45
00:02:59,000 --> 00:03:03,000
אחת היא קריאות.

46
00:03:03,000 --> 00:03:08,000
יתרון של שימוש זה הוא להגדיר # קריאות.

47
00:03:08,000 --> 00:03:11,000
כשאני קורא את הקוד הזה, אני יכול לראות מה קורה.

48
00:03:11,000 --> 00:03:15,000
>> אני יכול לראות במצב הזה כאן שאנו בודקים

49
00:03:15,000 --> 00:03:19,000
לגובה להיות <0, שיכולנו לקבלו גם מוגדרים

50
00:03:19,000 --> 00:03:22,000
להיות גובה מינימאלי או גובה דקות.

51
00:03:22,000 --> 00:03:25,000
היתרון השני הוא שאני יכול לקרוא ואז שאר השורה כדי לראות

52
00:03:25,000 --> 00:03:30,000
שגם אנחנו בודקים כדי לוודא שגובה הוא לא יותר מגובה המקסימום,

53
00:03:30,000 --> 00:03:35,000
כי אנחנו מתכוונים להמשיך ואילו הגובה הוא גדול יותר מגובה המקסימום.

54
00:03:35,000 --> 00:03:40,000
היתרון השני הוא, אם אני להתרחק קצת כאן

55
00:03:40,000 --> 00:03:49,000
אם אני מפעיל את התכנית הזאת ואני מפעיל אותו, למשל, עם 23 עכשיו,

56
00:03:49,000 --> 00:03:52,000
זה יהיה להדפיס את כל 23 שורות בדיוק כמו ש.

57
00:03:52,000 --> 00:03:54,000
אבל להגיד שאני רוצה לשנות את הגובה המרבי,

58
00:03:54,000 --> 00:03:57,000
ועכשיו אני רוצה להגביל את הגובה המרבי של פירמידות

59
00:03:57,000 --> 00:04:06,000
להיות איש רק לומר, שהיה פאנקי.

60
00:04:06,000 --> 00:04:14,000
# כולל <stdio.h>, # define MAX_HEIGHT,

61
00:04:14,000 --> 00:04:18,000
ונניח שאנחנו רוצים להגדיר אותו שווים ל 10.

62
00:04:18,000 --> 00:04:22,000
עכשיו, בשלב זה, כל מה שהיה צריך לעשות זה לשנות אותו במיקום זה.

63
00:04:22,000 --> 00:04:27,000
אני יכול להדר מחדש את הקוד, ועכשיו אם אני מנסה והקלד ב12,

64
00:04:27,000 --> 00:04:30,000
אותו ינחה אותי שוב.

65
00:04:30,000 --> 00:04:33,000
במקרה זה, אנחנו רק באמצעות MAX_HEIGHT פעם אחת.

66
00:04:33,000 --> 00:04:37,000
זה לא כל כך גדול של טרחה ללכת ב

67
00:04:37,000 --> 00:04:40,000
ולשנות אותו בלולאה בזמן, אם אתה צריך.

68
00:04:40,000 --> 00:04:44,000
אבל בתוכניות שבו אתה מפנה אותו מספר הקסם

69
00:04:44,000 --> 00:04:47,000
שוב ושוב, זה # להגדיר מנגנון הוא באמת שימושי

70
00:04:47,000 --> 00:04:52,000
כי אתה פשוט לשנות אותו פעם אחת בחלק העליון של קובץ זה בדרך כלל שבו אתה שם אותם

71
00:04:52,000 --> 00:04:57,000
והשינוי מחלחל דרך שאר הקבצים.

72
00:04:57,000 --> 00:05:02,000
>> דברים שרציתי לציין במשימה הזאת הוא נראה לי ממש נחמדים,

73
00:05:02,000 --> 00:05:05,000
אחד מהם היה השמות של המשתנים.

74
00:05:05,000 --> 00:05:14,000
אתה רואה כאן שיש לנו משתנה בשם שלם שורה ונקרא גובה.

75
00:05:14,000 --> 00:05:20,000
רווחים, hashes, זה עוזר להפוך את הקוד לקריא יותר קטן,

76
00:05:20,000 --> 00:05:25,000
עושה את זה קצת יותר מובן מה בעצם קורה.

77
00:05:25,000 --> 00:05:31,000
זאת בניגוד לשימוש, למשל, אותיות אקראיות

78
00:05:31,000 --> 00:05:35,000
או סתם קשקוש לחלוטין.

79
00:05:35,000 --> 00:05:39,000
דבר אחרון שאני מוכן להצביע הוא שבלולאות,

80
00:05:39,000 --> 00:05:45,000
לעתים קרובות משתנה אלה איטרטור, הדלפקים האלה שבם אתה משתמש בלולאות,

81
00:05:45,000 --> 00:05:51,000
זה סטנדרטי וקונבנציונלי כדי להתחיל אותם עם שתי i ואז י ולאחר מכן k

82
00:05:51,000 --> 00:05:54,000
והולך משם, אם אתה צריך עוד משתנה,

83
00:05:54,000 --> 00:05:56,000
וזו רק מוסכמה.

84
00:05:56,000 --> 00:05:58,000
יש הרבה מוסכמות.

85
00:05:58,000 --> 00:06:00,000
זה תלוי בשפת תכנות שאתה משתמש.

86
00:06:00,000 --> 00:06:04,000
אבל ב-C, שמתחילים בדרך כלל עם i.

87
00:06:04,000 --> 00:06:08,000
זה לא הגיוני להשתמש, למשל, או ב

88
00:06:08,000 --> 00:06:13,000
בהתאם למצב.

89
00:06:13,000 --> 00:06:15,000
זהו זה לזה.

90
00:06:15,000 --> 00:06:25,000
אם אתה עכשיו למשוך את הגרסות 2, תראה עוד מריו,

91
00:06:25,000 --> 00:06:29,000
ואת זה הוא דומה לאחד האחר שראינו הרגע,

92
00:06:29,000 --> 00:06:32,000
אבל זה סוג של משהו מגניב.

93
00:06:32,000 --> 00:06:38,000
אם נסתכל על סעיף זה ממש כאן בתוך פנימי ללולאה,

94
00:06:38,000 --> 00:06:44,000
הם משתמשים באיזה תחביר מחפש מטורף כאן ממש במשפט הזה.

95
00:06:44,000 --> 00:06:47,000
זה נקרא מפעיל משולש.

96
00:06:47,000 --> 00:06:53,000
זה הצהרה אם אחרת הנדחסת לשורה אחת.

97
00:06:53,000 --> 00:06:57,000
המצב זה הוא חלק בתוך סוגריים.

98
00:06:57,000 --> 00:07:05,000
זה שווה ערך לאמירה אם j גובה <- אני - 1.

99
00:07:05,000 --> 00:07:10,000
ואז מה את התוכן שאם יהיה בלוק הוא המרחב

100
00:07:10,000 --> 00:07:16,000
ולאחר מכן את התוכן של מה יהיה אחר הוא זה #.

101
00:07:16,000 --> 00:07:20,000
זה מהות של הקצאת שטח למשתנה זה.

102
00:07:20,000 --> 00:07:24,000
זה לשים את החלל בתוכן של משתנה הבלוק,

103
00:07:24,000 --> 00:07:29,000
אם תנאי זה מתקיים, ואם מצבו לא נפגש,

104
00:07:29,000 --> 00:07:32,000
אז משתנה הבלוק מקבל זה #.

105
00:07:32,000 --> 00:07:37,000
ואז, כמובן, במקום לבנות את כל מחרוזת

106
00:07:37,000 --> 00:07:43,000
ומדפיס את כל מה בסוף פתרון זה מדפיס אותו תו אחד בכל פעם.

107
00:07:43,000 --> 00:07:48,000
די מגניב.

108
00:07:48,000 --> 00:07:53,000
>> עוד כמה דברים להסתכל. נצטרך להמשיך הלאה לחמדנים.

109
00:07:53,000 --> 00:07:58,000
עכשיו, אם אנחנו מסתכלים על חמדן, פתרון ראשון זה

110
00:07:58,000 --> 00:08:00,000
משתמש באלה # מגדיר לא מעט.

111
00:08:00,000 --> 00:08:06,000
יש לנו קבוע שהוגדר לכל אחד מהמספרים השונים בתכנית זו.

112
00:08:06,000 --> 00:08:12,000
יש לנו אחת לסנאט לדולר, אחד לרבעים, עשר הסנאט, הניקל ופרוטות,

113
00:08:12,000 --> 00:08:15,000
ועכשיו אם אנחנו לגלול למטה ולקרוא את הקוד,

114
00:08:15,000 --> 00:08:22,000
אנו יכולים לראות את כל מה שיעשה, ואילו לולאת הדפסה סטנדרטית.

115
00:08:22,000 --> 00:08:25,000
סוג של עיקר הבעיה היה להבין כי

116
00:08:25,000 --> 00:08:29,000
אתה צריך להמיר את המצוף שאתה קורא במשתמש מספר שלם

117
00:08:29,000 --> 00:08:32,000
מדויק כדי לעשות את החשבון, וזה בגלל

118
00:08:32,000 --> 00:08:36,000
עם מספרי נקודה צפו, כמו שדברנו בהרצאה קצרה,

119
00:08:36,000 --> 00:08:41,000
זה לא אפשרי כדי לייצג במדויק כל ערך בודד על קו המספר

120
00:08:41,000 --> 00:08:47,000
כי יש ערכים רבים לאין שיעור שבין 3 ו, יניחו, 3.1 אפילו.

121
00:08:47,000 --> 00:08:54,000
אתה יכול לקבל 3.01 ו3.001 ו3.0001, ואתה יכול להמשיך.

122
00:08:54,000 --> 00:09:00,000
מתברר בכל פעם שאתה עובד עם כסף, לעתים קרובות אתה רוצה להמיר אותו

123
00:09:00,000 --> 00:09:05,000
לפורמט שלם, כך שאתה לא מאבד פרוטות ולכל מיני דברים.

124
00:09:05,000 --> 00:09:09,000
עושה את זה ולעיגול היה מפתח.

125
00:09:09,000 --> 00:09:14,000
פתרון זה השתמש באלגוריתם פשוט לגמרי, גדול,

126
00:09:14,000 --> 00:09:17,000
אשר מופחת מספר הסנאטים שנותרו, 1 לפי רבעונים,

127
00:09:17,000 --> 00:09:19,000
לאחר מכן על ידי מטבעות, ולאחר מכן על ידי מטבעים, אז בפרוטות,

128
00:09:19,000 --> 00:09:24,000
ומוסיף למספר מטבעים בכל פעם.

129
00:09:24,000 --> 00:09:31,000
>> פתרון נוסף שאנו רואים, כפי שזום החוצה וללכת לגרסה 4,

130
00:09:31,000 --> 00:09:40,000
הייתה התחלה דומה מאוד אבל div וmod להשתמש במקום זאת

131
00:09:40,000 --> 00:09:44,000
זכות לכאן כדי לחשב את מספר הסנאטים.

132
00:09:44,000 --> 00:09:50,000
זה, במספר הרבעים שווה למספר הסנאטים מחולקים 25,

133
00:09:50,000 --> 00:09:53,000
והסיבה זו היא עובדת בגלל שאנחנו עושים חלוקת מספר שלמה,

134
00:09:53,000 --> 00:09:58,000
כך שזה משליך כל שארית.

135
00:09:58,000 --> 00:10:02,000
[סטודנטים] האם יש לנו להגיב חיפוש?

136
00:10:02,000 --> 00:10:05,000
זה מאוד תלוי.

137
00:10:05,000 --> 00:10:08,000
[סטודנטים] אתה להעיר יותר מקוד ממש כאן.

138
00:10:08,000 --> 00:10:16,000
כן, ולכן יש חבורה של פילוסופיות שונות על זה.

139
00:10:16,000 --> 00:10:21,000
הפילוסופיה האישית שלי היא שהקוד שלך הוא באמת את האמת,

140
00:10:21,000 --> 00:10:24,000
כמו הקוד שלך הוא מה באמת נמצא בביצוע במחשב,

141
00:10:24,000 --> 00:10:29,000
וכן את הקוד שלך צריך להיות קריא ככול האפשר שלא מחייב כמו הערות רבות.

142
00:10:29,000 --> 00:10:33,000
עם זאת, כאשר אתה עושה את של מסובך דברים שהם סוג מתמטי

143
00:10:33,000 --> 00:10:38,000
או אלגוריתמי, זה טוב למי להגיב, כך שאתה יכול

144
00:10:38,000 --> 00:10:43,000
להוסיף ממד נוסף, שכבה נוספת למי שקורא את הקוד שלך.

145
00:10:43,000 --> 00:10:49,000
בפתרונות אלו, לעתים קרובות הם הגיבו יותר בכבדות רק בגלל

146
00:10:49,000 --> 00:10:52,000
אנחנו רוצים להיות מסוגלים להפיץ אותם ויש אנשים לאסוף אותם

147
00:10:52,000 --> 00:10:56,000
ולקרוא אותם די בקלות.

148
00:10:56,000 --> 00:11:05,000
אבל בהחלט, אני מסכים שזה כבד.

149
00:11:05,000 --> 00:11:07,000
[סטודנטים] אבל במקרה של ספק, עבור כבד יותר?

150
00:11:07,000 --> 00:11:10,000
במקרה של ספק, עבור כבד יותר.

151
00:11:10,000 --> 00:11:17,000
חלק מהאנשים לפעמים אומרים 0 תמורה או משהו כזה.

152
00:11:17,000 --> 00:11:20,000
אני חושב שזה מגוחך תגובה.

153
00:11:20,000 --> 00:11:22,000
ברור שזה מה שקורה.

154
00:11:22,000 --> 00:11:25,000
אני לא צריך לספר לי באנגלית ש.

155
00:11:25,000 --> 00:11:28,000
לפעמים אנשים כותבים דברים כמו "kthxbai!"

156
00:11:28,000 --> 00:11:32,000
זה די חמוד אבל גם לא,

157
00:11:32,000 --> 00:11:35,000
שלא עושה את ההבדל בין נקודות להעיר או לא.

158
00:11:35,000 --> 00:11:41,000
אלו סוגים של הערות הם רק חה, חה.

159
00:11:41,000 --> 00:11:43,000
מגניב.

160
00:11:43,000 --> 00:11:48,000
>> בשלב זה, בואו נתחיל לעבוד על בעיית הגדרת סעיף 3 של שאלות.

161
00:11:48,000 --> 00:11:52,000
אם אתם מושכים את זה שוב,

162
00:11:52,000 --> 00:11:55,000
כמו בשבוע שעבר, אנחנו לא מתכוונים לצפות במכנסיים הקצרים בסעיף זה.

163
00:11:55,000 --> 00:12:00,000
אנחנו נודיע לכם לעשות את זה בזמן שלך ולדבר על השאלות.

164
00:12:00,000 --> 00:12:05,000
אבל עכשיו בסעיף זה אנחנו הולכים לבלות קצת יותר זמן

165
00:12:05,000 --> 00:12:11,000
מדבר על פחות מיסודות הקידוד

166
00:12:11,000 --> 00:12:15,000
כמו שעשינו בשבוע שעבר, ובמקום זאת, אנחנו הולכים להתמקד יותר ב

167
00:12:15,000 --> 00:12:22,000
קצת יותר מהתאוריה, ולכן מדבר על החיפוש בינארי ולאחר מכן מיון.

168
00:12:22,000 --> 00:12:27,000
מאלה מכם שעוקבים יחד עם ההרצאה,

169
00:12:27,000 --> 00:12:30,000
מישהו יכול לתת לי סיכום של מה ההבדל

170
00:12:30,000 --> 00:12:35,000
בין החיפוש בינארי והחיפוש ליניארי?

171
00:12:35,000 --> 00:12:37,000
מה קורה? בטח.

172
00:12:37,000 --> 00:12:42,000
חיפושי חיפוש ינארית באמצעות כל אלמנט ברשימה הממוינת

173
00:12:42,000 --> 00:12:45,000
אחד אחד על ידי אחד אחד על ידי אחד,

174
00:12:45,000 --> 00:12:50,000
וחיפוש בינארי חלק הרשימה ל 2 קבוצות,

175
00:12:50,000 --> 00:12:57,000
בודק אם ערך המפתח שאתה מחפש הוא גדול יותר או קטן יותר מערך נקודת האמצע

176
00:12:57,000 --> 00:13:00,000
שאתה פשוט נמצא, ואם זה פחות מ, זה הולך עם הרשימה הנמוכה

177
00:13:00,000 --> 00:13:03,000
ולאחר מכן חלק את זה שוב, עושה את אותו התפקיד

178
00:13:03,000 --> 00:13:07,000
כל הדרך למטה עד שהוא מוצא את נקודת האמצע כדי להיות שווה הערך עצמו.

179
00:13:07,000 --> 00:13:10,000
נכון.

180
00:13:10,000 --> 00:13:12,000
>> למה אכפת לנו?

181
00:13:12,000 --> 00:13:20,000
למה אנחנו מדברים על חיפוש בינארי לעומת החיפוש ליניארי?

182
00:13:20,000 --> 00:13:22,000
כן.

183
00:13:22,000 --> 00:13:24,000
בינארי הוא הרבה יותר מהר, ולכן אם תכפיל את גודל הבעיה

184
00:13:24,000 --> 00:13:27,000
זה לוקח עוד צעד אחד ולא כמות כפולה.

185
00:13:27,000 --> 00:13:29,000
בדיוק.

186
00:13:29,000 --> 00:13:31,000
זאת תשובה גדולה.

187
00:13:31,000 --> 00:13:36,000
חיפוש בשכבות רבה בודק מרכיב אחד בכל פעם,

188
00:13:36,000 --> 00:13:39,000
וכפי שראינו ביום הראשון של הרצאה

189
00:13:39,000 --> 00:13:42,000
כאשר הדוד עבר למשל ספר הטלפון שלו

190
00:13:42,000 --> 00:13:45,000
ותלש דף אחד של ספר טלפונים בזמן

191
00:13:45,000 --> 00:13:47,000
וכל זמן עושה את זה שוב ושוב ושוב,

192
00:13:47,000 --> 00:13:51,000
זה הולך לקחת אותו באמת הרבה זמן כדי למצוא מישהו בספר הטלפונים,

193
00:13:51,000 --> 00:13:55,000
אלא אם כן, כמובן, הוא היה מחפש מישהו ממש בתחילתו של אלף הבית.

194
00:13:55,000 --> 00:14:00,000
בחיפוש בינארי, אתה יכול ללכת הרבה יותר מהר,

195
00:14:00,000 --> 00:14:05,000
וזה לא רק במהירות כפולה או 3 פעמים מהר או 4 פעמים באותה מהירות.

196
00:14:05,000 --> 00:14:13,000
אבל הבעיה הולכת וקטנה וקטנה הרבה יותר מהר.

197
00:14:13,000 --> 00:14:17,000
כדי להמחיש זאת, תתחילו לדבר על מה שקורה

198
00:14:17,000 --> 00:14:21,000
כאשר אנו כותבים חיפוש בינארי.

199
00:14:21,000 --> 00:14:27,000
הבעיה העומדת על הפרק היא שאם יש לי מערך של מספרים,

200
00:14:27,000 --> 00:14:40,000
תגיד, 1, 2, 3, 5, 7, 23, 45, 78, 12323,

201
00:14:40,000 --> 00:14:47,000
ולאחר מכן 9 עם טונה של 0s אחריו,

202
00:14:47,000 --> 00:14:52,000
אנחנו רוצים להיות מסוגלים להבין מהר מאוד מה הוא ב

203
00:14:52,000 --> 00:14:57,000
זה מערך של מספרים.

204
00:14:57,000 --> 00:15:00,000
אני יודע שזה נראה קצת מטופש וקצת מאולץ,

205
00:15:00,000 --> 00:15:02,000
כי כרגע זה.

206
00:15:02,000 --> 00:15:05,000
יש לנו מערך שאין לו הרבה מאוד אלמנטים בזה,

207
00:15:05,000 --> 00:15:08,000
ואם אני שואל את אחד מכם כדי להבין אם או לא

208
00:15:08,000 --> 00:15:11,000
23 הם במערך, אתה יכול לעשות את זה די מהר

209
00:15:11,000 --> 00:15:16,000
רק העף מבט בזה ואומר לי כן או לא.

210
00:15:16,000 --> 00:15:20,000
האנלוגי לשקול הוא לדמיין אם זה היה, יניח,

211
00:15:20,000 --> 00:15:27,000
גיליון אלקטרוני של Excel עם 10,000 שורות, 20000 שורות.

212
00:15:27,000 --> 00:15:31,000
כמובן, אתה יכול לעשות את הפקודה או F F השליטה ולחפש משהו.

213
00:15:31,000 --> 00:15:33,000
אתה יכול גם להשתמש במסננים, וחומר החיפוש,

214
00:15:33,000 --> 00:15:37,000
אם היה לך להסתכל דרך אותו קו קובץ על ידי שורה אחרת שורה, אבל,

215
00:15:37,000 --> 00:15:40,000
זה ייקח לך הרבה זמן כדי למצוא אותו.

216
00:15:40,000 --> 00:15:42,000
זה כמו סוג של בדוגמא ספר הטלפונים, גם בי

217
00:15:42,000 --> 00:15:44,000
אף אחד לא מסתכל בספר עמוד אחד טלפון בכל פעם.

218
00:15:44,000 --> 00:15:47,000
בדרך כלל, הם פותחים אותו לאמצע,

219
00:15:47,000 --> 00:15:50,000
או במקרה של הרבה ספרי טלפונים ומילונים בי

220
00:15:50,000 --> 00:15:54,000
למעשה יש לכם את זה רגש על האות הראשונה,

221
00:15:54,000 --> 00:16:01,000
להעיפך שלאות הראשונה ולפתוח ולהתחיל ללכת דרך שם.

222
00:16:01,000 --> 00:16:03,000
>> מזכיר לי את השם שלך שוב. >> סם.

223
00:16:03,000 --> 00:16:05,000
סם.

224
00:16:05,000 --> 00:16:11,000
כמו סם אמר, שתהליך החיפוש ליניארי הולך להיות ממש איטי,

225
00:16:11,000 --> 00:16:15,000
ובמקום עם חיפוש בינארי, את אופן הפעולה הוא ש

226
00:16:15,000 --> 00:16:21,000
בכל פעם שאנו עוברים איטרציה של אלגוריתם החיפוש שלנו,

227
00:16:21,000 --> 00:16:27,000
אנחנו הולכים לחלק את הרשימה לשתיים, למעשה,

228
00:16:27,000 --> 00:16:33,000
לשתי רשימות קטנות יותר.

229
00:16:33,000 --> 00:16:39,000
ולאחר מכן באיטרציה הבאה של הלולאה, אנחנו נחלק את זה שוב

230
00:16:39,000 --> 00:16:44,000
לרשימות אחרות, קטנות יותר.

231
00:16:44,000 --> 00:16:48,000
כפי שניתן לראות, הבעיה הולכת ונעשתה קטנה יותר ויותר

232
00:16:48,000 --> 00:16:55,000
בגלל שאנחנו לשמור על החצי שלכת של הרשימה בכל פעם אחת.

233
00:16:55,000 --> 00:16:59,000
איך זה עובד שנזרק?

234
00:16:59,000 --> 00:17:05,000
רק כתזכורת, מה אנחנו הולכים לעשות אם היינו מחשב

235
00:17:05,000 --> 00:17:11,000
ואנחנו, למשל, מחפשים את המספר 5 ברשימה זו

236
00:17:11,000 --> 00:17:15,000
הוא שהיינו קוטף מספר באמצע.

237
00:17:15,000 --> 00:17:26,000
באמצע הרשימה זו, משום שיש 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 מספרים,

238
00:17:26,000 --> 00:17:32,000
שניקח את המספר אחת בעמדה 4 או בעמדה 5,

239
00:17:32,000 --> 00:17:38,000
והיינו קוראים לזה באמצע הרשימה שלנו.

240
00:17:38,000 --> 00:17:42,000
בחר מספר באמצע.

241
00:17:42,000 --> 00:17:51,000
ואז, בדיוק כמו שסם אמר שנבדוק כדי לראות אם המספר שהוא שווה

242
00:17:51,000 --> 00:17:59,000
למספר שאנחנו רוצים לקבל או המספר הרצוי שלנו.

243
00:17:59,000 --> 00:18:06,000
אם זה שווה, אז אנחנו כבר מצאנו את זה. אנחנו ננצח.

244
00:18:06,000 --> 00:18:12,000
אם זה לא שווה, אז יש כמה מקרים.

245
00:18:12,000 --> 00:18:15,000
שני המקרים הם גם המספר חייב להיות גדול מהמספר שאנחנו מסתכלים עליו,

246
00:18:15,000 --> 00:18:19,000
או שזה פחות מ.

247
00:18:19,000 --> 00:18:25,000
אם זה גדול יותר, אנו עוברים לצד ימין.

248
00:18:25,000 --> 00:18:33,000
ואם זה פחות, אנו עוברים לצד השמאל.

249
00:18:33,000 --> 00:18:41,000
ואז אנחנו חוזרים על כל התהליך שוב

250
00:18:41,000 --> 00:18:48,000
שתי המחצית הימנית או המחצית השמאלית של הרשימה.

251
00:18:48,000 --> 00:18:51,000
>> הבעיה הראשונה בסעיף של היום היא להבין

252
00:18:51,000 --> 00:18:55,000
איך אנחנו יכולים באמת להתחיל לבטא את זה בקוד C.

253
00:18:55,000 --> 00:18:58,000
יש לנו pseudocode כאן.

254
00:18:58,000 --> 00:19:04,000
מה יהיה לנו להתחיל לעשות הוא אני אעצור מרחב חדש לגמרי,

255
00:19:04,000 --> 00:19:09,000
שמירת גרסה זו, כך שיש לנו הערות אלה למועד מאוחר יותר,

256
00:19:09,000 --> 00:19:20,000
אנחנו נמחק את כל זה, ולאחר מכן להעתיק ולהדביק מסט הבעיה

257
00:19:20,000 --> 00:19:26,000
את המידע הזה במקומותינו, ואני מקווה שזה לא ישבור.

258
00:19:26,000 --> 00:19:28,000
מושלם.

259
00:19:28,000 --> 00:19:33,000
אם אתם עושים את כל זה, להעתיק ולהדביק את הקוד הזה לתוך החלל החדש שלך,

260
00:19:33,000 --> 00:19:43,000
לתוך אחד ריק.

261
00:19:43,000 --> 00:19:47,000
בואו ננסה דניאל. אם לקמפל ולהריץ תכנית זו, זה עובד?

262
00:19:47,000 --> 00:19:49,000
המספר >> מה זה אומר?

263
00:19:49,000 --> 00:19:53,000
זה אומר השליטה מגיעה סוף הפונקציה שאינה מבוטלת.

264
00:19:53,000 --> 00:19:55,000
כן, אז תן לי לנסות להפעיל אותו.

265
00:19:55,000 --> 00:19:59,000
האם אתם ראיתם את זה קודם? אתה יודע מה זה אומר?

266
00:19:59,000 --> 00:20:01,000
אוקיי, בואו ננתח את זה קצת.

267
00:20:01,000 --> 00:20:10,000
זה אומר בfile.c על קו 9, העמודה 1 יש לנו טעות, בדיוק כמו שאתה אמרת,

268
00:20:10,000 --> 00:20:16,000
וזה אומר שזה נובע מאזהרת השגיאה ואזהרת סוג התמורה.

269
00:20:16,000 --> 00:20:18,000
זה נראה כמו משהו שקורה עם טיפוס ההחזרה, וזה הגיוני.

270
00:20:18,000 --> 00:20:21,000
יש לנו פונקציה שאינה מבוטלת, מה שאומר שיש לנו פונקציה

271
00:20:21,000 --> 00:20:24,000
שלא מחזיר מבוטל.

272
00:20:24,000 --> 00:20:27,000
פונקצית חלל היא אחד שנראית כך:

273
00:20:27,000 --> 00:20:35,000
החלל foo (), וזה בטל משום סוג ההחזרה הוא ריק,

274
00:20:35,000 --> 00:20:38,000
מה שאומר שאם יש לנו משהו בפה

275
00:20:38,000 --> 00:20:45,000
כמו בתמורה 1, הייתי מקבל שגיאת מהדר עבור זה.

276
00:20:45,000 --> 00:20:49,000
עם זאת, יש לנו פונקציה שאינה מבוטלת.

277
00:20:49,000 --> 00:20:51,000
הפונקציה הלא המבוטלת שלנו במקרה זה היא פונקצית החיפוש שלנו

278
00:20:51,000 --> 00:20:56,000
כי יש לו סוג החזרה של bool.

279
00:20:56,000 --> 00:20:59,000
כשזה אומר שהשליטה מגיעה לסוף הפונקציה שאינה מבוטלת,

280
00:20:59,000 --> 00:21:02,000
זה בגלל שהחיפוש אינו קיים הצהרת תמורה.

281
00:21:02,000 --> 00:21:04,000
זה לא חוזר שום דבר מהסוג bool.

282
00:21:04,000 --> 00:21:09,000
>> אנחנו יכולים לתקן את זה, ומה שאתם חושבים

283
00:21:09,000 --> 00:21:13,000
חיפוש צריך לחזור כברירת מחדל?

284
00:21:13,000 --> 00:21:16,000
מה צריך להיות ערך החזרת ברירת המחדל של חיפוש?

285
00:21:16,000 --> 00:21:19,000
כי זה מה שאנחנו יכולים לשים בסוף.

286
00:21:19,000 --> 00:21:21,000
שרלוט, האם יש לך-?

287
00:21:21,000 --> 00:21:23,000
אמת או שקר? >> אמת או שקר.

288
00:21:23,000 --> 00:21:26,000
איזה מהם?

289
00:21:26,000 --> 00:21:28,000
שקר. אני לא יודע.

290
00:21:28,000 --> 00:21:30,000
שקר? בואו ננסה את זה.

291
00:21:30,000 --> 00:21:32,000
למה את אומר את חזרת השווא? זה אינטואיציה רבה.

292
00:21:32,000 --> 00:21:35,000
[שארלוט] אני לא יודע.

293
00:21:35,000 --> 00:21:39,000
אנחנו הולכים לחזור שווא במקרה זה כי זה יהיה ברירת המחדל שלנו

294
00:21:39,000 --> 00:21:44,000
אם מסיבה כלשהי הרשימה ריקה או המחט

295
00:21:44,000 --> 00:21:46,000
שאנחנו מחפשים לא קיימים.

296
00:21:46,000 --> 00:21:50,000
ואז ממש בסוף, אם לא מוקדם יותר בהחזר אמיתי בפונקציה זו,

297
00:21:50,000 --> 00:21:55,000
אנחנו תמיד יודעים שהתפקוד הזה יגיד לא, זה לא במערך.

298
00:21:55,000 --> 00:21:58,000
זה לא בערימת השחת.

299
00:21:58,000 --> 00:22:03,000
עכשיו, אם אנחנו לקמפל ולהריץ אותו, תנו לי להציל את זה, כדי שנוכל למשוך אותו.

300
00:22:03,000 --> 00:22:08,000
עכשיו, אם אנחנו לקמפל ולהריץ את התכנית שלנו, שהיא בונה.

301
00:22:08,000 --> 00:22:12,000
אנחנו מקבלים את הפקודה הקטנה שלנו.

302
00:22:12,000 --> 00:22:20,000
אם אני מכה 4-אוי.

303
00:22:20,000 --> 00:22:25,000
זה לא להדפיס כל דבר. זה נראה כאילו כל מה שהסתיים בסדר.

304
00:22:25,000 --> 00:22:35,000
אנחנו חייבים למלא את זה פנימה

305
00:22:35,000 --> 00:22:39,000
דברנו על האלגוריתם בpseudocode קצת לפני.

306
00:22:39,000 --> 00:22:44,000
תן לי לראות, לשמור את זה,

307
00:22:44,000 --> 00:22:49,000
ואני אוציא אלגוריתם שאחזור שוב.

308
00:22:49,000 --> 00:22:51,000
בואו פגענו בבחור הזה. לא.

309
00:22:51,000 --> 00:22:58,000
זה מה שיש.

310
00:22:58,000 --> 00:23:03,000
איך עושים את זה?

311
00:23:03,000 --> 00:23:11,000
מה יהיה אסטרטגיה טובה להתחלה נכונה בקוד זה?

312
00:23:11,000 --> 00:23:16,000
אתה צריך לבחור את המספר באמצע.

313
00:23:16,000 --> 00:23:23,000
איך לבחור מספר באמצע מערך?

314
00:23:23,000 --> 00:23:25,000
יש לך הצעות?

315
00:23:25,000 --> 00:23:27,000
[סטודנטים] strlen חלק 2.

316
00:23:27,000 --> 00:23:32,000
Strlen חלק 2. זה אחד גדול.

317
00:23:32,000 --> 00:23:35,000
Strlen עובד עם סוגים מיוחדים של מערכים.

318
00:23:35,000 --> 00:23:38,000
אילו סוגים של מערכים?

319
00:23:38,000 --> 00:23:44,000
מערכי מחרוזות, מערכי אופי.

320
00:23:44,000 --> 00:23:48,000
זה אותו הסוג של קונספט שאנחנו רוצים להחיל,

321
00:23:48,000 --> 00:23:52,000
אבל אנחנו לא יכולים להשתמש strlen מכיוון שאין לנו מערך של תווים.

322
00:23:52,000 --> 00:23:55,000
יש לנו מערך של ints.

323
00:23:55,000 --> 00:23:58,000
אבל מה strlen לקבל עבורנו?

324
00:23:58,000 --> 00:24:01,000
אתה יודע מה הוא מקבל עבורנו?

325
00:24:01,000 --> 00:24:03,000
[סטודנטים] strlen מביא אותנו לכל אורך.

326
00:24:03,000 --> 00:24:05,000
בדיוק, זה מביא אותנו לכל אורך.

327
00:24:05,000 --> 00:24:09,000
Strlen מקבל אורך של המערך עבורנו.

328
00:24:09,000 --> 00:24:14,000
>> איך אנחנו מקבלים את זה בתכנית החיפוש בינארי שלנו?

329
00:24:14,000 --> 00:24:18,000
איך היית לקבל את אורך מערך?

330
00:24:18,000 --> 00:24:20,000
[סטודנטים] strlen?

331
00:24:20,000 --> 00:24:25,000
אתה יכול לקבל את אורך מערך מעוצב כהלכה C מחרוזת עם strlen.

332
00:24:25,000 --> 00:24:31,000
הבעיה, אם כי, היא שאין לנו מערך מחרוזת.

333
00:24:31,000 --> 00:24:36,000
אם אנחנו מסתכלים אחורה בקוד זה, יש לנו מערך השלם הזה.

334
00:24:36,000 --> 00:24:38,000
איך אנחנו יודעים כמה זמן זה?

335
00:24:38,000 --> 00:24:44,000
[סטודנטים] האם יש מקבילה לנקודת סיום 1, כמו שאני או משהו int?

336
00:24:44,000 --> 00:24:49,000
מתברר למעשה הוא לא קיים, וזאת בדרך, זה

337
00:24:49,000 --> 00:24:52,000
אחד מהדברים האלה שפשוט טובים לדעת על C,

338
00:24:52,000 --> 00:24:57,000
כי אין דרך להשיג את אורך מערך

339
00:24:57,000 --> 00:24:59,000
אם כל מה שאני נותן לך הוא המערך.

340
00:24:59,000 --> 00:25:02,000
הסיבה שזה עובד עם מחרוזות, סיבת strlen עבודות,

341
00:25:02,000 --> 00:25:06,000
משום שאם מחרוזת היא בפורמט מתאים,

342
00:25:06,000 --> 00:25:12,000
זה יהיה \ 0 תו מיוחד שממש בסוף.

343
00:25:12,000 --> 00:25:16,000
>> אתה יכול גם לדמיין אם יש לך מחרוזת כראוי מעוצבת

344
00:25:16,000 --> 00:25:20,000
ואין \ 0 דמות שם, אז כל העניין לא עובד.

345
00:25:20,000 --> 00:25:22,000
[סטודנטים] האם אתה יכול להוסיף את \ 0?

346
00:25:22,000 --> 00:25:24,000
אנחנו יכולים במקרה זה.

347
00:25:24,000 --> 00:25:29,000
אנחנו יכולים להוסיף איזה \ 0

348
00:25:29,000 --> 00:25:33,000
או איזה סוג של מסמני אופי ולאחר מכן להשתמש בו.

349
00:25:33,000 --> 00:25:36,000
אבל זה לא ממש הולך לעבודה

350
00:25:36,000 --> 00:25:40,000
בגלל \ 0 הם לסוג char,

351
00:25:40,000 --> 00:25:43,000
וכאן יש לנו ints.

352
00:25:43,000 --> 00:25:46,000
הדבר השני הוא שאם היינו משתמש בערך מיוחד

353
00:25:46,000 --> 00:25:49,000
כמו -1, כדי לסמן את סוף המערך

354
00:25:49,000 --> 00:25:54,000
אז אנחנו לא יכולים לאחסן -1 במערכים השלמים שלנו.

355
00:25:54,000 --> 00:25:56,000
אנחנו נתקענו.

356
00:25:56,000 --> 00:26:00,000
מתבררת שהדרך היחידה להשיג את האורך

357
00:26:00,000 --> 00:26:03,000
של מערך ב C היא למעשה לזכור את זה

358
00:26:03,000 --> 00:26:08,000
כשאתה מגדיר את זה ולאחר מכן להעביר אותו מסביב עם המערך

359
00:26:08,000 --> 00:26:14,000
כך שבכל פעם שיש לי פונקציה שהולכת לעשות קצת עבודה

360
00:26:14,000 --> 00:26:18,000
על מערך של מספרים שלמים או מרחף או זוגות או מה יש לך,

361
00:26:18,000 --> 00:26:22,000
אני גם צריך לתת לפונקציה של אורך המערך,

362
00:26:22,000 --> 00:26:26,000
וזה בדיוק מה שעשינו כאן בפונקצית החיפוש.

363
00:26:26,000 --> 00:26:30,000
אם אתה מסתכל, מה שאנחנו עשינו כאשר אנו עוברים במערך שלנו כאן,

364
00:26:30,000 --> 00:26:36,000
אנחנו גם עוברים באורך, הגודל.

365
00:26:36,000 --> 00:26:41,000
זה פשוט קורה כי יש לנו משתנה בשם זה פה,

366
00:26:41,000 --> 00:26:43,000
פרמטר זה או ויכוח.

367
00:26:43,000 --> 00:26:46,000
זה נקרא רשימה של פונקצית הטיעון או רשימת פרמטרים,

368
00:26:46,000 --> 00:26:51,000
ואלה נקראים גם טיעונים או פרמטרים.

369
00:26:51,000 --> 00:26:53,000
אנשים משתמשים במונחים שונים בזמנים שונים.

370
00:26:53,000 --> 00:26:55,000
לפעמים אני להחליפם בעצמי.

371
00:26:55,000 --> 00:27:00,000
זה פשוט כל כך קורה כי משתנה זה כאן בשם דומה

372
00:27:00,000 --> 00:27:03,000
לזה # להגדיר עד כאן.

373
00:27:03,000 --> 00:27:06,000
אבל הם לא אותו הדבר.

374
00:27:06,000 --> 00:27:11,000
השווי כן קובע.

375
00:27:11,000 --> 00:27:14,000
>> אם אתה מסתכל על מה שקורה כאן, אנו מצהירים

376
00:27:14,000 --> 00:27:18,000
המערך שלנו int, שקראנו לי מספרים.

377
00:27:18,000 --> 00:27:23,000
אנחנו נתנו לו הגודל שלנו, אשר תואם אותנו # להגדיר למעלה בקומה העליונה.

378
00:27:23,000 --> 00:27:27,000
זה הולך להיות 8.

379
00:27:27,000 --> 00:27:35,000
ואז, כשאז לקרוא לפונקצית החיפוש שלנו למטה,

380
00:27:35,000 --> 00:27:40,000
אנחנו עוברים במספר שאנחנו רוצים לחפש, שאנחנו מתבקשים,

381
00:27:40,000 --> 00:27:43,000
קבל מהמשתמש.

382
00:27:43,000 --> 00:27:46,000
אנחנו עוברים במערך, מספרים זה,

383
00:27:46,000 --> 00:27:51,000
ואז יש לנו גם לעבור בגודל של המערך,

384
00:27:51,000 --> 00:27:57,000
ולאחר מכן את הערך של גודל 8 מאוחסן

385
00:27:57,000 --> 00:28:01,000
או עבר לגודל משתנה שלם בשם זה.

386
00:28:01,000 --> 00:28:08,000
יש לנו את גודלו של המערך.

387
00:28:08,000 --> 00:28:11,000
עכשיו, אם לחזור למה שאנחנו מדברים עליו קודם לכן,

388
00:28:11,000 --> 00:28:14,000
אני חושב שהמסים העלו את הטענה כי מה שאנחנו צריכים לעשות הוא לקבל את האורך של המערך

389
00:28:14,000 --> 00:28:20,000
ולחלק אותו על ידי 2, ושייתן לנו את נקודת אמצע.

390
00:28:20,000 --> 00:28:22,000
בואו נראים.

391
00:28:22,000 --> 00:28:25,000
האם יש לי מישהו לכתוב את זה ולשמור אותו במרחב שלהם?

392
00:28:25,000 --> 00:28:27,000
מה דעתך על ליילה?

393
00:28:27,000 --> 00:28:31,000
האם יש לי שאתה כותב בזה?

394
00:28:31,000 --> 00:28:35,000
לכתוב את השורה הראשונה שבו אתה לוקח את האורך של המערך ולקבל את נקודת האמצע

395
00:28:35,000 --> 00:28:41,000
ולאחסן אותו במשתנה חדשה.

396
00:28:41,000 --> 00:28:44,000
אני אתן לך כמה שניות. האם אתה מוכן?

397
00:28:44,000 --> 00:28:46,000
[סטודנטים לא נשמעו]

398
00:28:46,000 --> 00:28:50,000
בטח, יכולתי להיות לך לחשב את נקודת האמצע

399
00:28:50,000 --> 00:28:55,000
של מערך ערימת השחת בתוך פונקציית החיפוש

400
00:28:55,000 --> 00:29:03,000
שימוש באורך של מערך ערימת השחת, שהוא משתנה הגודל?

401
00:29:03,000 --> 00:29:08,000
שום דבר לא מסובך כאן.

402
00:29:08,000 --> 00:29:12,000
[ליילה] רק גודל / 2 ופשוט-

403
00:29:12,000 --> 00:29:17,000
ולשמור אותו, ולחץ על הכפתור השמור עד כאן בחלקו העליון,

404
00:29:17,000 --> 00:29:19,000
ואנחנו למשוך אותו.

405
00:29:19,000 --> 00:29:22,000
מושלם.

406
00:29:22,000 --> 00:29:28,000
הנה. מדהים.

407
00:29:28,000 --> 00:29:30,000
>> כפי שהוא, יהיה זה לקמפל?

408
00:29:30,000 --> 00:29:32,000
[ליילה] לא, זה צריך להיות גבוה יותר.

409
00:29:32,000 --> 00:29:34,000
[נייט] כן, אז מה שאנחנו צריכים לעשות?

410
00:29:34,000 --> 00:29:36,000
[ליילה] כמו נקודת אמצע או משהו int.

411
00:29:36,000 --> 00:29:41,000
מדהים. כן, בואו נעשה את זה, int אמצע = גודל.

412
00:29:41,000 --> 00:29:44,000
האם זה לקמפל?

413
00:29:44,000 --> 00:29:47,000
בואו למחוק תגובה זו ולקבל את זה בדרך.

414
00:29:47,000 --> 00:29:50,000
מה שלא יהיה לקמפל על זה?

415
00:29:50,000 --> 00:29:52,000
אנחנו לא עושים שום דבר עם מספר שלם,

416
00:29:52,000 --> 00:29:55,000
כך שאנחנו צריכים להדפיס אותו או משהו כזה.

417
00:29:55,000 --> 00:29:58,000
כן, בדיוק.

418
00:29:58,000 --> 00:30:00,000
אנחנו נקבל משתנים שאינם בשימוש.

419
00:30:00,000 --> 00:30:02,000
מה עוד הוא לא הולך לעבוד על זה?

420
00:30:02,000 --> 00:30:06,000
אני חושב שאמרת משהו, סם. פסיק.

421
00:30:06,000 --> 00:30:08,000
כן, אני חסר פסיק אלה.

422
00:30:08,000 --> 00:30:14,000
זה הולך להיות דבר קבוע לאורך המסלול של המונח.

423
00:30:14,000 --> 00:30:17,000
הדבר האחרון שאעשה הוא אני אשים קצת חלל לבן משני הצדדים

424
00:30:17,000 --> 00:30:23,000
של מפעיל זה כאן, מכיוון שזה בדרך כלל מה שאנחנו עושים

425
00:30:23,000 --> 00:30:26,000
על פי מדריך הסגנון שלנו.

426
00:30:26,000 --> 00:30:29,000
יש לנו את נקודת האמצע של המערך שלנו.

427
00:30:29,000 --> 00:30:32,000
עכשיו, אם אנחנו זוכרים בחזרה לאלגוריתם שלנו,

428
00:30:32,000 --> 00:30:37,000
מה היה הצעד השני שאנחנו צריכים לעשות ברגע שיש לנו את נקודת אמצע?

429
00:30:37,000 --> 00:30:42,000
[סטודנטים] אם זה גדול יותר [לא ברור].

430
00:30:42,000 --> 00:30:48,000
כן, אז יש לנו לעשות איזה השוואה, ומה שאנו משווים כאן?

431
00:30:48,000 --> 00:30:53,000
אתה אמרת שאם הוא גדול מ. מה זה שבמשפט מתייחס?

432
00:30:53,000 --> 00:30:57,000
המספר שעולה, אם זה גדול יותר מנקודת האמצע, ואז ללכת עד למערך?

433
00:30:57,000 --> 00:31:05,000
בדיוק, כך המספר אשר עולה כאשר אנו-

434
00:31:05,000 --> 00:31:10,000
המחט, ולכן אנחנו בהשוואה למחט,

435
00:31:10,000 --> 00:31:12,000
ומה שאנו משווים נגד המחט?

436
00:31:12,000 --> 00:31:15,000
בגלל המחט היא מה שאנחנו מחפשים.

437
00:31:15,000 --> 00:31:18,000
אנחנו משווים את זה כדי להגיע לנקודת האמצע.

438
00:31:18,000 --> 00:31:21,000
>> אבל האם זה הגיוני לבדוק

439
00:31:21,000 --> 00:31:27,000
אם נקודת אמצע = מחט?

440
00:31:27,000 --> 00:31:32,000
האם זה הגיוני?

441
00:31:32,000 --> 00:31:35,000
האם מישהו לא מסכים?

442
00:31:35,000 --> 00:31:40,000
בואו לנסות את זה, אם (מחט == נקודת אמצע).

443
00:31:40,000 --> 00:31:42,000
[סטודנטים] האם printf שמצאו אותו.

444
00:31:42,000 --> 00:31:51,000
[נייט] printf ("מצאתי אותו \ n");

445
00:31:51,000 --> 00:31:56,000
אחרת, אני מתכוון להתחיל לעשות משהו שונה כאן.

446
00:31:56,000 --> 00:32:00,000
אני הולך להתחיל לשים פלטה סביב אם הצהרות כל הזמן

447
00:32:00,000 --> 00:32:05,000
רק בגלל שאם תוסיפו יותר דברים, ולאחר מכן

448
00:32:05,000 --> 00:32:07,000
אנחנו לא מקבלים את המהדרים.

449
00:32:07,000 --> 00:32:09,000
כן, סם. יש לך נקודה.

450
00:32:09,000 --> 00:32:12,000
הבעיה היא שנקודת אמצע מייצגת עמדה במערך,

451
00:32:12,000 --> 00:32:15,000
אבל אתה יכול לקבל את זה כדי לייצג את הערך שבעמדתו של המערך.

452
00:32:15,000 --> 00:32:17,000
זו נקודה מצוינת.

453
00:32:17,000 --> 00:32:19,000
האם כולם שומעים את מה שאמר סם?

454
00:32:19,000 --> 00:32:22,000
הוא אמר שנקודת האמצע היא כ

455
00:32:22,000 --> 00:32:28,000
מייצג רק את העמדה במערך, אבל זה לא המרכיב הממשי במערך.

456
00:32:28,000 --> 00:32:30,000
אם אתה חושב על הקוד כפי שנכתב ממש עכשיו,

457
00:32:30,000 --> 00:32:35,000
אם נסתכל על המערך הזה כאן למטה, שבו יש 8 אלמנטים בזה,

458
00:32:35,000 --> 00:32:39,000
מהו הערך של נקודת האמצע הולכת להיות בתפקיד הזה?

459
00:32:39,000 --> 00:32:41,000
[סטודנטים] 4.

460
00:32:41,000 --> 00:32:45,000
[נייט] 4.

461
00:32:45,000 --> 00:32:51,000
אם נסתכל למספר 4 -

462
00:32:51,000 --> 00:32:54,000
ואנחנו רק יכולים להפעיל את הקוד הזה ולשים פרצוף עצוב מעט בכאן

463
00:32:54,000 --> 00:32:58,000
כי אנחנו לא מוצאים אותו, אם אנו מפעילים את הקוד הזה

464
00:32:58,000 --> 00:33:04,000
כמו עכשיו, העלאתו, בניין, שלא לגלול אותי,

465
00:33:04,000 --> 00:33:09,000
אם אנחנו מחפשים את המספר 4 ו,

466
00:33:09,000 --> 00:33:18,000
אנחנו מצאנו אותו, אבל אנחנו לא מקבלים את זה לprintf כן.

467
00:33:18,000 --> 00:33:23,000
אחת סיבות לכך הן שאנחנו לא החזר אמיתי,

468
00:33:23,000 --> 00:33:26,000
אבל אנחנו באמת למצוא את מספר 4?

469
00:33:26,000 --> 00:33:28,000
וסם אומר לא.

470
00:33:28,000 --> 00:33:31,000
מה מצא?

471
00:33:31,000 --> 00:33:35,000
אנחנו באמת מצאנו את נקודת האמצע, שאם יסתכלו על המערך כאן למטה,

472
00:33:35,000 --> 00:33:38,000
זה הולך להיות האלמנט בעמוד 4 שאנחנו מסתכלים,

473
00:33:38,000 --> 00:33:42,000
שהוא 23.

474
00:33:42,000 --> 00:33:46,000
>> איך אנחנו בעצם מקבלים אלמנט שבנקודת האמצע

475
00:33:46,000 --> 00:33:48,000
ולא רק את נקודת האמצע עצמו?

476
00:33:48,000 --> 00:33:52,000
[סטודנטים] היינו נכנס char או משהו?

477
00:33:52,000 --> 00:33:55,000
מה שהיה עושה, פשוט מתוך סקרנות?

478
00:33:55,000 --> 00:33:57,000
האם אתה יכול לפרט קצת יותר?

479
00:33:57,000 --> 00:34:02,000
אתה צריך לשנות את המיקום למספר,

480
00:34:02,000 --> 00:34:05,000
כך שאתה חייב ליצור קשר כלשהו, ​​אני חושב שזה char, אבל זה לא יכול להיות.

481
00:34:05,000 --> 00:34:07,000
כן, זה נקודה טובה.

482
00:34:07,000 --> 00:34:12,000
אנחנו כבר עושים הרבה עמדות המרה זה לתווים, תווים אלה,

483
00:34:12,000 --> 00:34:14,000
בשתי קבוצות הבעיה הראשונות.

484
00:34:14,000 --> 00:34:18,000
מתברר כי כאן, זה כמעט דומה ל

485
00:34:18,000 --> 00:34:24,000
גישה לתו ה-i במחרוזת, אם זה נשמע הגיוני.

486
00:34:24,000 --> 00:34:30,000
כאן אנו רוצים לגשת לאלמנט נקודת האמצע.

487
00:34:30,000 --> 00:34:34,000
איך עושה את זה?

488
00:34:34,000 --> 00:34:39,000
קווין, האם יש לך הצעות כיצד תוכל לעשות זאת?

489
00:34:39,000 --> 00:34:44,000
אתה יכול לעשות את ערימת שחת, סוגר פתוח, באמצע, סגר את הסוגר.

490
00:34:44,000 --> 00:34:46,000
האם אתה יכול לכתוב את זה בשבילנו?

491
00:34:46,000 --> 00:34:51,000
שמור אותו בכאן, ואנחנו למשוך את זה.

492
00:34:51,000 --> 00:34:56,000
אנחנו מסתכלים על קו 9 זה,

493
00:34:56,000 --> 00:34:59,000
ואנחנו מבינים שאנחנו לא רוצים להשוות את המחט למרכז,

494
00:34:59,000 --> 00:35:03,000
אבל במקום זה, אנחנו רוצים להשוות את המחט

495
00:35:03,000 --> 00:35:07,000
לאלמנט באמצע המיקום בתוך מערך ערימת השחת שלנו.

496
00:35:07,000 --> 00:35:10,000
מגניב.

497
00:35:10,000 --> 00:35:12,000
הנה.

498
00:35:12,000 --> 00:35:15,000
כן, זה נראה די טוב, אם (מחט בערימת שחת == [אמצע]).

499
00:35:15,000 --> 00:35:18,000
אנחנו מצאנו אותו.

500
00:35:18,000 --> 00:35:22,000
עכשיו אם אנחנו רצים בחזרה קוד להכין מלמעלה קצת-

501
00:35:22,000 --> 00:35:26,000
זה הידור, שהיא פועלת, ועכשיו אם אנחנו מסתכלים על 4,

502
00:35:26,000 --> 00:35:30,000
לא מצאנו את זה כי עכשיו אנחנו למעשה מקבלים את המספר 23.

503
00:35:30,000 --> 00:35:33,000
אנחנו מקבלים את הערך 23, וזה מה שאנחנו משווים למחט שלנו.

504
00:35:33,000 --> 00:35:35,000
אבל זה טוב. זה צעד בכיוון הנכון.

505
00:35:35,000 --> 00:35:37,000
>> זה מה שאנחנו מנסים לעשות.

506
00:35:37,000 --> 00:35:40,000
אנחנו לא מנסים להשוות את המחט נגד עמדות במערך

507
00:35:40,000 --> 00:35:44,000
אלא נגד הגורמים בפועל במערך.

508
00:35:44,000 --> 00:35:49,000
אם נסתכל שוב עכשיו בשלב הבא באלגוריתם שלנו,

509
00:35:49,000 --> 00:35:51,000
מה הצעד הבא?

510
00:35:51,000 --> 00:35:57,000
ליילה כבר הזכירה את זה בקצרה.

511
00:35:57,000 --> 00:36:00,000
[סטודנטים] בדקו אם זה גדול יותר או קטן יותר ואז להחליט לאיזה כיוון לנוע.

512
00:36:00,000 --> 00:36:03,000
[נייט] כן, אז איך אנחנו עושים את זה?

513
00:36:03,000 --> 00:36:07,000
האם אתה יכול לשים בחלק-I'll לחסוך גרסה זו,

514
00:36:07,000 --> 00:36:13,000
ואז אם אתה מכניס כמה שורות שתעשינה את זה.

515
00:36:13,000 --> 00:36:15,000
כן, שרלוט. >> יש לי שאלה.

516
00:36:15,000 --> 00:36:19,000
לא היה צריך להיות נקודת אמצע - 1 כי הדבר הראשון הוא

517
00:36:19,000 --> 00:36:26,000
זה 0 אינדקס, כך שאם אנחנו שמים 4, זה לא ממש האופי שאנחנו מחפשים?

518
00:36:26,000 --> 00:36:30,000
כן, ובעיה האחרת עם שהוא

519
00:36:30,000 --> 00:36:35,000
זה מציאה גדולה, כי מה שקורה בסופו קורה אולי

520
00:36:35,000 --> 00:36:42,000
אם להמשיך לנוע ואנחנו אף פעם לא להתאים בתחילה?

521
00:36:42,000 --> 00:36:46,000
אני מניח מה שעשוי בסופו של דבר עושה מנסה לגשת

522
00:36:46,000 --> 00:36:49,000
האלמנט בעמדה 8 של המערך,

523
00:36:49,000 --> 00:36:53,000
שבמקרה זה לא קיים.

524
00:36:53,000 --> 00:36:56,000
אנחנו רוצים לעשות איזה חשבון את העובדה

525
00:36:56,000 --> 00:36:59,000
כי יש לנו כמה אינדוקס אפס.

526
00:36:59,000 --> 00:37:05,000
[שארלוט] סליחה, התכוון אמצע - 1 בסוגריים המרובעים.

527
00:37:05,000 --> 00:37:08,000
אנחנו יכולים לעשות את זה.

528
00:37:08,000 --> 00:37:10,000
אנחנו נחזור לנושא הזה בקצת.

529
00:37:10,000 --> 00:37:13,000
ברגע שנתחיל להגיע לlooping בפועל,

530
00:37:13,000 --> 00:37:16,000
זה הרגע שבי אנחנו באמת רואים את זה בא לידי הביטוי.

531
00:37:16,000 --> 00:37:21,000
לעת עתה, אנחנו יכולים לעשות את זה, אבל אתה לגמרי נכון.

532
00:37:21,000 --> 00:37:28,000
כי אינדקס אפס יהיה השפעה שאנחנו צריכים להסביר.

533
00:37:28,000 --> 00:37:30,000
בואו נראים.

534
00:37:30,000 --> 00:37:34,000
>> איך הוא גדול יותר ופחות מ-?

535
00:37:34,000 --> 00:37:36,000
[סטודנטים] אני מקבל איך לעשות יותר ומחלק פחות.

536
00:37:36,000 --> 00:37:41,000
אני רק לא היה בטוח מה להדפיס אם אתה מוצא שזה פחות מנקודת אמצע ערימת השחת או גדול מ.

537
00:37:41,000 --> 00:37:43,000
כאן אני יכול לשמור את מה ברצינות,

538
00:37:43,000 --> 00:37:47,000
[נייט] כן, אם אתה שומר את מה שיש לך, ואנחנו נמשוך אותו.

539
00:37:47,000 --> 00:37:49,000
הנה.

540
00:37:49,000 --> 00:37:51,000
[סטודנטים] ושמתי סימני שאלה על מה שאני לא יודע.

541
00:37:51,000 --> 00:37:54,000
[נייט] זה נראה נהדר.

542
00:37:54,000 --> 00:37:58,000
כאן יש לנו סימני שאלה כי אנחנו עדיין לא יודעים

543
00:37:58,000 --> 00:38:06,000
מה שאנחנו הולכים לעשות מאוד עדיין.

544
00:38:06,000 --> 00:38:12,000
מה היינו רוצה לעשות, אופס, יש לנו כמה פלטות כל פאנקי עלינו.

545
00:38:12,000 --> 00:38:15,000
אנחנו לתקן פלטות אלה.

546
00:38:15,000 --> 00:38:19,000
הנה.

547
00:38:19,000 --> 00:38:22,000
ואז מה שאנחנו רוצים לעשות, על פי האלגוריתם שלנו,

548
00:38:22,000 --> 00:38:27,000
אם אנחנו לא מוצאים את המחט?

549
00:38:27,000 --> 00:38:32,000
תגיד במקרה שהמחט היא פחות ממה שאנחנו מסתכלים. קווין.

550
00:38:32,000 --> 00:38:34,000
מסתכל רק על חיצו השמאלי.

551
00:38:34,000 --> 00:38:40,000
טוב, אז ישים את תגובה בכאן שאומרת "להסתכל על חיצו השמאלי."

552
00:38:40,000 --> 00:38:46,000
ואם המחט גדולה מערימת השחת בנקודת האמצע, מה אנחנו רוצים לעשות?

553
00:38:46,000 --> 00:38:48,000
[סטודנטים] ואז אתה מסתכל מהצד הימני.

554
00:38:48,000 --> 00:38:53,000
תראה את החצי הימני, "יסתכל על מחציתו הימנית."

555
00:38:53,000 --> 00:38:58,000
גם בכלל לא רע.

556
00:38:58,000 --> 00:39:05,000
אוקיי, אז בנקודה זו, דברים נראים טוב למדי.

557
00:39:05,000 --> 00:39:13,000
הבעיה עם הקוד שנכתב היא מה?

558
00:39:13,000 --> 00:39:15,000
[סטודנטים] אתה לא צריך נקודתי קצה לחצאים.

559
00:39:15,000 --> 00:39:18,000
נכון, אין לנו נקודתי קצה לחצאים.

560
00:39:18,000 --> 00:39:20,000
אנחנו גם רק הולכים לעבור פעם אחת את זה.

561
00:39:20,000 --> 00:39:23,000
אנחנו רק הולכים להסתכל על נקודת אמצע אחת.

562
00:39:23,000 --> 00:39:27,000
כך או הרכיב הוא שם, או שזה לא.

563
00:39:27,000 --> 00:39:34,000
כדי להשלים את זה, יצטרך לעשות איזה חזרה.

564
00:39:34,000 --> 00:39:39,000
אנחנו צריכים לחזור שוב ושוב עד שנמצאנו כי

565
00:39:39,000 --> 00:39:43,000
אם הרכיב הוא שם כי יש לנו הצטמצמתי ולבסוף מצאתי אותו,

566
00:39:43,000 --> 00:39:46,000
או שהוא לא שם כי אנחנו בדקנו דרך כל הדברים

567
00:39:46,000 --> 00:39:52,000
בחצי המתאימים של המערך ומצא כי דבר הוא לשם.

568
00:39:52,000 --> 00:39:56,000
>> בכל פעם שיש לנו חזרות זה קורות, מה אנחנו הולכים להשתמש?

569
00:39:56,000 --> 00:39:58,000
[סטודנטים] לולאה.

570
00:39:58,000 --> 00:40:00,000
איזה לולאה. כן.

571
00:40:00,000 --> 00:40:03,000
[סטודנטים] אנחנו יכולים לעשות עשו תוך לולאה ויש לו לעשות את זה ואז בזמן

572
00:40:03,000 --> 00:40:10,000
המחט לא שווה, אני לא בטוח לאן אני הולך עם זה.

573
00:40:10,000 --> 00:40:18,000
אבל כמו סוג של לעשות את זה כל עוד זה לא שווה הערך שקלט המשתמש.

574
00:40:18,000 --> 00:40:21,000
כן, אז בואו נראים, איך זה יכול לכתוב את עצמו?

575
00:40:21,000 --> 00:40:23,000
את אמר לי להשתמש עשה תוך לולאה.

576
00:40:23,000 --> 00:40:26,000
מאיפה מתחיל?

577
00:40:26,000 --> 00:40:33,000
[סטודנטים] מייד לאחר הגודל / 2.

578
00:40:33,000 --> 00:40:42,000
[נייט] אוקיי, ומה אנחנו הולכים לעשות?

579
00:40:42,000 --> 00:40:44,000
אנו נמלאים בזמן מאוחר יותר.

580
00:40:44,000 --> 00:40:46,000
מה אנחנו הולכים לעשות?

581
00:40:46,000 --> 00:40:49,000
[סטודנטים] האם אנחנו לא רוצים לעשות את כל הדברים שיש לנו באם החלק?

582
00:40:49,000 --> 00:40:52,000
[נייט] האם כל החומר הזה, גדול.

583
00:40:52,000 --> 00:40:55,000
העתק ודבק.

584
00:40:55,000 --> 00:40:59,000
הו, בן אדם.

585
00:40:59,000 --> 00:41:03,000
בואו נראה אם ​​זה עובד, אם תוכל כרטיסייה על זה.

586
00:41:03,000 --> 00:41:08,000
יפה.

587
00:41:08,000 --> 00:41:16,000
אוקיי, ואנחנו חוסכים את זה כל כך יש לכם את זה.

588
00:41:16,000 --> 00:41:21,000
בסדר, ואנחנו הולכים לעשות את זה בזמן,

589
00:41:21,000 --> 00:41:25,000
מה היה המצב בזמן שהיית אחרי?

590
00:41:25,000 --> 00:41:31,000
[סטודנטים] בזמן שהמחט אינה שווה, ולכן כמו הסימן הקריא.

591
00:41:31,000 --> 00:41:37,000
אבל אני לא בטוח בדיוק מה זה עדיין.

592
00:41:37,000 --> 00:41:39,000
[נייט] כן, זו דרך אחת לעשות את זה.

593
00:41:39,000 --> 00:41:41,000
סם, יש לך הערה?

594
00:41:41,000 --> 00:41:43,000
[סם] נזכרתי שכשהסתכלתי על סרטוני וידאו,

595
00:41:43,000 --> 00:41:48,000
לקחתי את צילום מסך של אחד כמו כשעשינו pseudocode לזה,

596
00:41:48,000 --> 00:41:52,000
יש קשר כלשהו בין מקס ודקות.

597
00:41:52,000 --> 00:41:58,000
אני חושב שזה היה משהו כמו אם המקסימום הוא אי פחות מ דקות.

598
00:41:58,000 --> 00:42:00,000
קבל אותו.

599
00:42:00,000 --> 00:42:04,000
[סם] או כמו אם המקסימום הוא לא פחות מ דקות או משהו כזה,

600
00:42:04,000 --> 00:42:06,000
כי אז זה אומר שאתה כבר חפשת הכל.

601
00:42:06,000 --> 00:42:13,000
>> כן, אז מה זה נשמע כמו מקס ודקות היו מתייחסים?

602
00:42:13,000 --> 00:42:16,000
[סם] ערכים ש- מספרים שלמים כי הם הולכים לשנות

603
00:42:16,000 --> 00:42:18,000
יחסית למקום בו אנו שמים את נקודת האמצע.

604
00:42:18,000 --> 00:42:20,000
בדיוק.

605
00:42:20,000 --> 00:42:24,000
[סם] בשלב זה, זה הולך [לא ברור] לחשב את המקסימום ודקות.

606
00:42:24,000 --> 00:42:29,000
נקודת אמצע היא זה מקסימום ורעיון דקות.

607
00:42:29,000 --> 00:42:35,000
האם זה הגיוני לאנשים?

608
00:42:35,000 --> 00:42:39,000
אם היינו מתחיל להסתכל על איך אנחנו הולכים לעשות איטרציה זו,

609
00:42:39,000 --> 00:42:43,000
אתה לגמרי נכון שאנחנו רוצים להשתמש בסוג מסוים של לעשות-תוך לולאה.

610
00:42:43,000 --> 00:42:49,000
אבל אני מניח שאם אזכור מה קורה בנקודה של מערך זה

611
00:42:49,000 --> 00:42:53,000
ומה בעצם קורה, אני הולך לכתוב פה,

612
00:42:53,000 --> 00:42:58,000
באיטרציה הראשונה של חיפוש בינארי, יש לנו,

613
00:42:58,000 --> 00:43:05,000
אני הולך להשתמש ב ודואר כדי לציין את ההתחלה.

614
00:43:05,000 --> 00:43:10,000
ואז בסוף המערך שלנו.

615
00:43:10,000 --> 00:43:14,000
אנחנו יודעים שהיא בתחילת 4 ממש כאן,

616
00:43:14,000 --> 00:43:18,000
ואנחנו יודעים שהם בסופו של דבר 108.

617
00:43:18,000 --> 00:43:23,000
אומר שאנחנו מחפשים את המספר 15.

618
00:43:23,000 --> 00:43:27,000
הפעם הראשונה שאנחנו עושים את זה, כמו שראינו קודם,

619
00:43:27,000 --> 00:43:30,000
נקודת האמצע היא גם הולכת להיות 16 או 23

620
00:43:30,000 --> 00:43:34,000
תלויים איך מחשבים את הדברים.

621
00:43:34,000 --> 00:43:37,000
מאז באופן שווה חלוקה באמצע היה נותנת לנו המרחב הזה

622
00:43:37,000 --> 00:43:42,000
בין 16 ו 23, אנחנו לא יכולים לחלק אותו שווים בשווים

623
00:43:42,000 --> 00:43:47,000
או לחלק אותו ולהגיע אל נקודת אמצע נכונה.

624
00:43:47,000 --> 00:43:49,000
אנחנו נסתכל על 16.

625
00:43:49,000 --> 00:43:55,000
אנחנו נבין "היי, 16> 15 שאנחנו מחפשים".

626
00:43:55,000 --> 00:43:59,000
אז להסתכל על חיצו השמאלי של המערך

627
00:43:59,000 --> 00:44:03,000
מה שנקבל בסופו של דבר עושה הוא שלכת

628
00:44:03,000 --> 00:44:07,000
כל חלק עליון זה

629
00:44:07,000 --> 00:44:16,000
ואמר, "בסדר, עכשיו נקודת הסיום שלנו הולכת להיות כאן."

630
00:44:16,000 --> 00:44:22,000
איטרציה הבאה של הלולאה שלנו, אנחנו מסתכלים עכשיו מערך זה,

631
00:44:22,000 --> 00:44:25,000
יעילות שהושלך חלק זה כי עכשיו

632
00:44:25,000 --> 00:44:30,000
אם אנחנו לוקחים את נקודת האמצע כדי להיות ההבדל בין ההתחלה והסוף,

633
00:44:30,000 --> 00:44:34,000
אנו מוצאים נקודת האמצע שלנו להיות 8,

634
00:44:34,000 --> 00:44:40,000
אשר לאחר מכן יכול לבדוק 8 כדי לראות איפה הוא ביחס למספר שאנחנו מחפשים,

635
00:44:40,000 --> 00:44:44,000
15, מוצא ש15 גדול,

636
00:44:44,000 --> 00:44:49,000
לכן יש לנו כדי לעבור לחלק הימני של הרשימה,

637
00:44:49,000 --> 00:44:51,000
אשר אנו יודעים כי אנחנו בני אדם, ואנחנו יכולים לראות את זה.

638
00:44:51,000 --> 00:44:54,000
אנחנו יודעים שהחלק הימני הולך להיות בו אנו מוצאים אותו,

639
00:44:54,000 --> 00:45:01,000
אבל המחשב לא יודע את זה, אז מה שנעשינו הוא שנהיה בפועל

640
00:45:01,000 --> 00:45:04,000
שזה יעלה, ועכשיו התחלה והסוף

641
00:45:04,000 --> 00:45:11,000
הן באותה הנקודה, ולכן נקודת האמצע הופכת את המספר רק ברשימה בשלב זה,

642
00:45:11,000 --> 00:45:16,000
שהוא בן 15, ואנחנו כבר מצאנו את זה.

643
00:45:16,000 --> 00:45:21,000
האם זה לשפוך קצת אור על איך כל זה המקסימום וסימון דקות הולכים,

644
00:45:21,000 --> 00:45:24,000
שמירה על מסלול של נקודתי הקצה של המערך כדי להבין

645
00:45:24,000 --> 00:45:35,000
כיצד לצמצם את הדברים?

646
00:45:35,000 --> 00:45:42,000
>> מה יקרה אם זה לא היה שווה 15 עכשיו?

647
00:45:42,000 --> 00:45:52,000
מה אם אנחנו מחפשים 15 ובמקום זאת, המספר הזה היה גם 16?

648
00:45:52,000 --> 00:45:54,000
היינו אומרים, "אוי, זה גדול.

649
00:45:54,000 --> 00:45:57,000
אנחנו רוצים לחזור לשמאל ".

650
00:45:57,000 --> 00:46:01,000
ואנחנו נעביר את הדואר שלנו בצד ימין,

651
00:46:01,000 --> 00:46:06,000
ובשלב זה יש לנו נקודת סיום שיהיה סותר.

652
00:46:06,000 --> 00:46:09,000
זה לא יהיה מסוגל לחפש כל אלמנטים נוספים

653
00:46:09,000 --> 00:46:13,000
כי עכשיו יש לנו נקודת הסיום שלנו ואת נקודת ההתחלה שלנו,

654
00:46:13,000 --> 00:46:16,000
המקסימום שלנו והדקות שלנו, עכשיו התהפכו.

655
00:46:16,000 --> 00:46:23,000
אנחנו חיפוש בכל המערך. אנחנו לא יכולים למצוא שום דבר.

656
00:46:23,000 --> 00:46:27,000
זו נקודה שבה היינו רוצה לומר, "טוב, אנחנו הולכים לעצור את האלגוריתם הזה.

657
00:46:27,000 --> 00:46:34,000
לא מצאנו שום דבר. אנחנו יודעים שזה לא לכאן. "

658
00:46:34,000 --> 00:46:36,000
איך זה קורה?

659
00:46:36,000 --> 00:46:40,000
[סטודנטים] איך בדיוק עושה את המחשב לעבור לסוף?

660
00:46:40,000 --> 00:46:45,000
כיצד הסיום אינו בסופו של לפני ההתחלה?

661
00:46:45,000 --> 00:46:48,000
הסוף מסתיים לפני התחילה

662
00:46:48,000 --> 00:46:54,000
בגלל המתמטיקה שאנחנו הולכים לעשות בכל פעם שאנחנו עושים את זה.

663
00:46:54,000 --> 00:47:00,000
הדרך בה אנו מחליפים היא אם אתה מסתכל בפעם הראשונה שאנחנו עושים עסקה זו

664
00:47:00,000 --> 00:47:03,000
שם יש לנו בתחילת 4 וסופו של דבר

665
00:47:03,000 --> 00:47:13,000
כל הדרך למטה ובאמצע 108, למשל, בגיל 16 -

666
00:47:13,000 --> 00:47:20,000
אני הולך לאפס את זה בחזרה 15-אם אתה מחפש 15,

667
00:47:20,000 --> 00:47:25,000
ידעתי שמה שעשינו כשבדקנו 16 וראו שזה היה גדול יותר

668
00:47:25,000 --> 00:47:28,000
ורציתי לבטל את כל החלק הימני של הרשימה,

669
00:47:28,000 --> 00:47:36,000
ראינו כי מה שרצינו לעשות הוא להעביר דואר זה ממש כאן.

670
00:47:36,000 --> 00:47:44,000
ביעילות, עבר לדואר קבל אחד לפני האמצע.

671
00:47:44,000 --> 00:47:48,000
כמו כן, כשעשינו חזרות זה של האלגוריתם

672
00:47:48,000 --> 00:47:51,000
ונקודת האמצע הייתה בשעת 8,

673
00:47:51,000 --> 00:47:55,000
מצאנו כי 8 <15, אז רצינו לעבור ב

674
00:47:55,000 --> 00:48:00,000
1 עבר נקודת האמצע.

675
00:48:00,000 --> 00:48:07,000
עכשיו, את ההתחלה וסוף שניהם ביחד בזה 15.

676
00:48:07,000 --> 00:48:10,000
>> אם הייתי קורה לחפש ערך אחר, ולא 15,

677
00:48:10,000 --> 00:48:14,000
או אם זה היו 15 במקום 16,

678
00:48:14,000 --> 00:48:20,000
היינו מוצא שהדואר אנחנו רוצים להעביר אחד לפני האמצע.

679
00:48:20,000 --> 00:48:33,000
עכשיו הדואר יהיה שם התהפך פחות מ b.

680
00:48:33,000 --> 00:48:39,000
הבה ללכת דרך איך אנחנו בסופו למעשה קידוד אלגוריתם זה.

681
00:48:39,000 --> 00:48:44,000
אנחנו יודעים שאנחנו רוצים שנהיה לי חישוב נקודת האמצע הזה.

682
00:48:44,000 --> 00:48:48,000
אנחנו יודעים גם שאנחנו רוצים לעקוב אחר ההתחלה והסוף של המערך

683
00:48:48,000 --> 00:48:51,000
של המערך הנוכחי שלנו, כך שנוכל להבין

684
00:48:51,000 --> 00:48:56,000
שהמחצית שמאלית זו של הרשימה היא ואיפה במחצית הימנית של הרשימה היא.

685
00:48:56,000 --> 00:49:03,000
אנחנו עושים את זה עם כל אחד מתחיל ומסתיים,

686
00:49:03,000 --> 00:49:07,000
או שאנו יכולים לקרוא להם דקות ומקסימום.

687
00:49:07,000 --> 00:49:10,000
אני אשתמש מתחיל ומסתיים שלב זה.

688
00:49:10,000 --> 00:49:15,000
כאשר אנו מתחילים, אם אנחנו מסתכלים אחורה בדוגמא שלנו כאן למטה,

689
00:49:15,000 --> 00:49:20,000
ההתחלה שלנו הייתה מוגדרת מאוד בהתחלה של המערך, כטבעי.

690
00:49:20,000 --> 00:49:25,000
מה היה מדד זה? מה שלנו צריך להתחיל להיות?

691
00:49:25,000 --> 00:49:27,000
דניאל.

692
00:49:27,000 --> 00:49:30,000
[דניאל] שחת [0].

693
00:49:30,000 --> 00:49:37,000
[נייט] כן, כדי שנוכל להגדיר אותו שווה לערימת שחת [0].

694
00:49:37,000 --> 00:49:40,000
הבעיה, אם כי, היא שזה לא נותן לנו את מיקומו של היסוד הראשון.

695
00:49:40,000 --> 00:49:45,000
זה נותן לנו המדד של הרכיב הראשון או הערך הממשי שבמקום הראשון.

696
00:49:45,000 --> 00:49:47,000
[סטודנטים] זה יהיה להמיר ל.20?

697
00:49:47,000 --> 00:49:52,000
[נייט] מה זה יעשה הוא, טוב, זה לא יעשה את כל המרות.

698
00:49:52,000 --> 00:49:56,000
מה זה יעשה לו זה יהיה לאחסן 4 במתחיל,

699
00:49:56,000 --> 00:49:59,000
ואז זה יהיה קשה לעשות השוואות נגד להתחיל

700
00:49:59,000 --> 00:50:03,000
כי בגין יקיים את הערך של 4,

701
00:50:03,000 --> 00:50:06,000
המהווה את תחילתו של המערך שלנו,

702
00:50:06,000 --> 00:50:08,000
אבל אנחנו רוצים לעקוב אחר המדדים במערך

703
00:50:08,000 --> 00:50:11,000
בניגוד לערכים.

704
00:50:11,000 --> 00:50:17,000
אנחנו בעצם נשתמש 0, ככה.

705
00:50:17,000 --> 00:50:20,000
לסוף מערך שארלוט הביא את זה קצת יותר מוקדם.

706
00:50:20,000 --> 00:50:23,000
זה המקום בו אנו לוקחים בחשבון את אינדקס אפס.

707
00:50:23,000 --> 00:50:25,000
>> שרלוט, מה זה הסוף של המערך?

708
00:50:25,000 --> 00:50:28,000
מהו המדד של הסוף?

709
00:50:28,000 --> 00:50:30,000
[שארלוט] גודל - 1.

710
00:50:30,000 --> 00:50:32,000
כן, ושגודל אנחנו צריכים להשתמש?

711
00:50:32,000 --> 00:50:35,000
האם עלינו להשתמש בגודל הון או גודל אותיות קטן?

712
00:50:35,000 --> 00:50:37,000
גודל הון.

713
00:50:37,000 --> 00:50:42,000
במקרה זה, אנחנו יכולים להשתמש בגודל הון.

714
00:50:42,000 --> 00:50:45,000
אם רציתי בפונקציה זו כדי להיות ניידת

715
00:50:45,000 --> 00:50:48,000
ולהשתמש בפונקציה זו בתוכניות אחרות,

716
00:50:48,000 --> 00:50:50,000
אנו יכולים להשתמש בגודל קטן.

717
00:50:50,000 --> 00:50:52,000
זה גם בסדר.

718
00:50:52,000 --> 00:51:01,000
אבל שרלוט היא לגמרי נכונה שאנחנו רוצים שנהיה לי גודל - 1.

719
00:51:01,000 --> 00:51:03,000
בשלב זה,

720
00:51:03,000 --> 00:51:05,000
[סטודנטים] איך זה שאתה יכול להשתמש בגודל אותיות גדולים?

721
00:51:05,000 --> 00:51:07,000
איך זה שאנחנו יכולים להשתמש בגודל אותיות גדולים?

722
00:51:07,000 --> 00:51:13,000
מתברר כי אלה הם באמת מגדירים #,

723
00:51:13,000 --> 00:51:19,000
מתחת למכסת המנוע, טקסט כמו חיפוש והחלפה, אם זה נשמע הגיוני.

724
00:51:19,000 --> 00:51:24,000
כשאתה לקמפל את הקוד שלך, שלב preprocessing

725
00:51:24,000 --> 00:51:27,000
של המהדר עובר את הקובץ,

726
00:51:27,000 --> 00:51:31,000
וזה נראה לכל מקום שאתה כתבת גודל הון,

727
00:51:31,000 --> 00:51:39,000
והוא מחליף טקסט מילולי עם 8, סתם ככה.

728
00:51:39,000 --> 00:51:42,000
במובן זה, זה מאוד שונה ממשתנה.

729
00:51:42,000 --> 00:51:45,000
זה לא לוקח את כל מקום בזיכרון.

730
00:51:45,000 --> 00:51:52,000
זה טריק החלפת טקסט פשוט.

731
00:51:52,000 --> 00:51:57,000
במקרה זה, אנחנו הולכים להשתמש בגודל.

732
00:51:57,000 --> 00:52:01,000
מכאן אנו רוצים לעשות איזה חזרה,

733
00:52:01,000 --> 00:52:03,000
ואנחנו בדרך הנכונה עם עשה תוך הלולאה שלנו.

734
00:52:03,000 --> 00:52:08,000
אנחנו רוצים לעשות משהו עד שמצבו אינו מחזיק יותר,

735
00:52:08,000 --> 00:52:12,000
וכפי שראינו קודם, ראה שזה מצב

736
00:52:12,000 --> 00:52:19,000
אכן היה שאנחנו לא רוצים את הסוף

737
00:52:19,000 --> 00:52:24,000
להיות פחות מלהתחיל.

738
00:52:24,000 --> 00:52:26,000
>> זה תנאי העצירה שלנו.

739
00:52:26,000 --> 00:52:35,000
במקרה זה, אנחנו רוצים לעצור ולהכריז כמו: "היי, לא מצאנו שום דבר."

740
00:52:35,000 --> 00:52:43,000
כדי להביע את זה, אל רוצים להשתמש בסוג מסוים של לולאה.

741
00:52:43,000 --> 00:52:49,000
במקרה זה, זה יהיה עשה תוך לולאה, ללולאה, לולאה בזמן?

742
00:52:49,000 --> 00:52:51,000
יש לנו עשה תוך לולאה כאן.

743
00:52:51,000 --> 00:52:53,000
האם אתה חבר 'ה כמו שהגישה?

744
00:52:53,000 --> 00:52:59,000
האם אתה חושב שאנחנו צריכים לנסות גישה שונה?

745
00:52:59,000 --> 00:53:01,000
קווין, כל מחשבות?

746
00:53:01,000 --> 00:53:06,000
אנחנו יכולים להיות לולאה בזמן, כי אנחנו יודעים מרביים

747
00:53:06,000 --> 00:53:11,000
יהיה גדול יותר דקות בכל מקרה ההתחלה.

748
00:53:11,000 --> 00:53:14,000
כן, כך שאין אתחול שצריך לקרות.

749
00:53:14,000 --> 00:53:17,000
לולאותיהן עשה תוך נהדרות כאשר יש לך משהו כדי לאתחל

750
00:53:17,000 --> 00:53:21,000
לפני כן בדיקה, ואילו כאן

751
00:53:21,000 --> 00:53:26,000
אנחנו יודעים שאנחנו לא מתכוונים לשמור reinitializing הן מתחילות ומסתיימות

752
00:53:26,000 --> 00:53:28,000
בכל סיבוב של הלולאה.

753
00:53:28,000 --> 00:53:32,000
אנחנו יודעים שאנחנו רוצים לאתחל אותם, ואז לבדוק את המצב שלנו.

754
00:53:32,000 --> 00:53:38,000
במקרה זה, אני בעצם ללכת עם לולאה פשוטה.

755
00:53:38,000 --> 00:53:44,000
מתברר כי לולאות לעשות-בעוד משמשות למדי לעתים רחוקות.

756
00:53:44,000 --> 00:53:49,000
הרבה מקומות אפילו לא מלמדים לעשות בשעת לולאות.

757
00:53:49,000 --> 00:53:53,000
הם טובים לטיפול בקלט משתמש, כך שראינו הרבה מהם עד כה.

758
00:53:53,000 --> 00:53:59,000
אבל נורמלי ואילו לולאות הן הרבה יותר נפוץ.

759
00:53:59,000 --> 00:54:03,000
מתברר שמצב זה כפי שנכתב

760
00:54:03,000 --> 00:54:09,000
ממש לא עושה לנו הרבה טוב, ולמה זה?

761
00:54:09,000 --> 00:54:11,000
אני מצטער, אני לא יודע את שמך.

762
00:54:11,000 --> 00:54:13,000
אני ג'רי. >> מצטער?

763
00:54:13,000 --> 00:54:15,000
זה B-O-R-U-.

764
00:54:15,000 --> 00:54:18,000
אה, אוקיי.

765
00:54:18,000 --> 00:54:23,000
אני לא רואה אותך ברשימה שלי.

766
00:54:23,000 --> 00:54:26,000
אה, זה בגלל ש- הו, זה הגיוני.

767
00:54:26,000 --> 00:54:31,000
האם יש לך מושג למה לולאה בזמן זה עלולה שלא לפעול כמתוכנן,

768
00:54:31,000 --> 00:54:38,000
כפי שנכתב עם המצב?

769
00:54:38,000 --> 00:54:43,000
[ג'רי] אתה מתכוון כמו שאתה רוצה את כל הדברים אחריו לתוך-?

770
00:54:43,000 --> 00:54:46,000
כן, אז זה אחד.

771
00:54:46,000 --> 00:54:49,000
יכול להיות שנצטרך לשים את כל החומר הזה ללולאה בזמן, שהוא לגמרי נכון.

772
00:54:49,000 --> 00:54:55,000
הדבר השני שזה קצת יותר בעייתי, אם כי, הוא שמצב זה לא עובד.

773
00:54:55,000 --> 00:54:57,000
[סטודנטים] אתה צריך להעיף אותו.

774
00:54:57,000 --> 00:55:04,000
בסדר, אז מצב זה אף לא אהיה נכון בתחילה כמו שדברנו על זה.

775
00:55:04,000 --> 00:55:08,000
אנחנו רוצים לעשות משהו עד <הסוף מתחילים,

776
00:55:08,000 --> 00:55:13,000
אבל אנחנו רוצים לעשות משהו בזמן

777
00:55:13,000 --> 00:55:21,000
תתחיל ≤ הסוף.

778
00:55:21,000 --> 00:55:24,000
>> יש היפוך של ההיגיון שם.

779
00:55:24,000 --> 00:55:27,000
אני אשם בטעויות האלה כל הזמן.

780
00:55:27,000 --> 00:55:31,000
[סטודנטים] למה זה צריך להיות פחות או שווה ל?

781
00:55:31,000 --> 00:55:33,000
כי אתה זוכר את המקרה שהגענו ל

782
00:55:33,000 --> 00:55:36,000
שם היה רק ​​מרכיב אחד, ואנחנו היינו למטה,

783
00:55:36,000 --> 00:55:43,000
ואנחנו מסתכלים רק 15 במערך שלנו?

784
00:55:43,000 --> 00:55:47,000
וההתחלה שלנו והסוף שלנו היו אותו היסוד.

785
00:55:47,000 --> 00:55:50,000
אנחנו רוצים לוודא שאנחנו מטפלים במקרה זה.

786
00:55:50,000 --> 00:55:54,000
אם הייתי עושה ישר פחות מ,

787
00:55:54,000 --> 00:55:58,000
היינו יכול לרדת למערך 2-אלמנט היחיד.

788
00:55:58,000 --> 00:56:06,000
ברגע שהגענו עד שהאלמנט האחרון, אם זה היה עיקרון היסוד שלנו, לא הייתי מוצא אותו.

789
00:56:06,000 --> 00:56:10,000
עכשיו הוא כאן, אנחנו יכולים לעשות בדיוק כמו שאמרתם.

790
00:56:10,000 --> 00:56:15,000
אנחנו יכולים להתחיל נושרת חומר נכון לאמצע הלולאה בזמננו.

791
00:56:15,000 --> 00:56:20,000
אנחנו יכולים פלופ בנקודת האמצע שלנו.

792
00:56:20,000 --> 00:56:24,000
אנחנו יכולים לקחת את כל אלה אם ההצהרות,

793
00:56:24,000 --> 00:56:30,000
למשוך אותם מעשה תוך הלולאה הזו,

794
00:56:30,000 --> 00:56:34,000
פלופ ב,

795
00:56:34,000 --> 00:56:39,000
לנקות את הדברים קצת קטן,

796
00:56:39,000 --> 00:56:48,000
ואני אמשיך הלאה ולשמור גרסה זו.

797
00:56:48,000 --> 00:56:53,000
ובנקודה הזאת, אנחנו מקבלים די קרובים.

798
00:56:53,000 --> 00:56:55,000
סם.

799
00:56:55,000 --> 00:56:58,000
אני חושב שאתה גם צריך שיהיה לי אמצע int = גודל - 1/2.

800
00:56:58,000 --> 00:57:01,000
קבל את זה, גודל - 1/2.

801
00:57:01,000 --> 00:57:05,000
האם יש עוד משהו שאנחנו צריכים לשנות על אותה השורה?

802
00:57:05,000 --> 00:57:10,000
זה היה שידוך טוב.

803
00:57:10,000 --> 00:57:14,000
>> מה גודל עושה? האם אי פעם שינוי גודל?

804
00:57:14,000 --> 00:57:17,000
על מנת לשמור על הקו כזה, אנחנו צריכים לשנות את הגודל.

805
00:57:17,000 --> 00:57:21,000
אנחנו צריכים לשנות את הגודל בכל פעם שאנחנו הולכים מסביב ללולאה.

806
00:57:21,000 --> 00:57:25,000
אבל זוכר שהיו הולכים דרך הדוגמא שלנו רק קצת מוקדם יותר,

807
00:57:25,000 --> 00:57:30,000
והיו לנו התחלה בשעת 4

808
00:57:30,000 --> 00:57:33,000
וסופו של דבר כל הדרך ב 108?

809
00:57:33,000 --> 00:57:35,000
איך לחשב את נקודת האמצע?

810
00:57:35,000 --> 00:57:38,000
האם הייתי משתמש בגודל?

811
00:57:38,000 --> 00:57:40,000
או שהיינו באמצעות מתחיל ומסתיימים במקום זה?

812
00:57:40,000 --> 00:57:42,000
זה הבדל בין הסוף וההתחלה.

813
00:57:42,000 --> 00:57:50,000
בדיוק, ואיך בדיוק אני צריך לכתוב את זה, שרלוט?

814
00:57:50,000 --> 00:57:52,000
רק בסוף - להתחיל.

815
00:57:52,000 --> 00:57:55,000
לא היית צריך לעשות - 1

816
00:57:55,000 --> 00:57:58,000
משום - 1 נכלל בסופו של דבר ולהתחיל עם זה כבר.

817
00:57:58,000 --> 00:58:00,000
[נייט] גדול, את לגמרי נכון.

818
00:58:00,000 --> 00:58:03,000
אנחנו לא צריכים לעשות - 1 משום ש-- 1 נכלל

819
00:58:03,000 --> 00:58:08,000
והיוויתי כאשר אנו לאתחל את משתנת הסוף.

820
00:58:08,000 --> 00:58:11,000
>> האם יש עוד משהו שאני צריך לעשות מבחינה תחבירית יש קו זה הגיוני?

821
00:58:11,000 --> 00:58:13,000
[סטודנטים] פלוס מתחילה. >> פלוס להתחיל?

822
00:58:13,000 --> 00:58:15,000
[סטודנטים] בסוף.

823
00:58:15,000 --> 00:58:20,000
כי הוא מחושב כמחצית האורך בלבד.

824
00:58:20,000 --> 00:58:26,000
אתה צריך להוסיף להתחיל.

825
00:58:26,000 --> 00:58:31,000
[נייט] מה זה לחשב עבורנו?

826
00:58:31,000 --> 00:58:35,000
אם אנחנו חושבים על הסוף באיטרציה הראשונה של הלולאה,

827
00:58:35,000 --> 00:58:40,000
הסוף הולך להיות בעמדת הראשים 7.

828
00:58:40,000 --> 00:58:43,000
בגין הוא בעמדה 0.

829
00:58:43,000 --> 00:58:47,000
זכרו, אנחנו מחפשים שני

830
00:58:47,000 --> 00:58:52,000
עמדה 3 או עמדה 4.

831
00:58:52,000 --> 00:58:56,000
אם נסתכל על זה במתמטיקה, רק כדי לעשות את זה קצת יותר מוחשי,

832
00:58:56,000 --> 00:59:02,000
לשים כמה מספרים כאן, יש לנו 7, 0,

833
00:59:02,000 --> 00:59:10,000
כך 7-0, ולאחר מכן / 2

834
00:59:10,000 --> 00:59:19,000
הוא 3 בחטיבה שלמה, כי הוא.

835
00:59:19,000 --> 00:59:26,000
ואז אנחנו צריכים אז להוסיף חזרה להתחיל?

836
00:59:26,000 --> 00:59:28,000
אנחנו לא במקרה הזה.

837
00:59:28,000 --> 00:59:31,000
באיטרציה הראשונה, זה יהיה בסדר, כי בגין הוא 0.

838
00:59:31,000 --> 00:59:36,000
אבל כמו שאנו מתקדמים, אנו עושים באמת הכילו רק צריכים

839
00:59:36,000 --> 00:59:42,000
הסוף - מתחילים / 2.

840
00:59:42,000 --> 00:59:46,000
יש טריק אחד אחר כאן, וזה אחד מכלומר קדימות.

841
00:59:46,000 --> 00:59:49,000
[סטודנטים] האם אנחנו צריכים סוגריים?

842
00:59:49,000 --> 00:59:53,000
[נייט] בדיוק, וזה בגלל שאם לא לשים הסוגריים האלה,

843
00:59:53,000 --> 00:59:58,000
אז הקו הזה יתפרש במקום

844
00:59:58,000 --> 01:00:09,000
כ( סוף) - (מתחילים / 2), שאנחנו בהחלט לא רוצים.

845
01:00:09,000 --> 01:00:11,000
תיזהר כללי קדימות אלה.

846
01:00:11,000 --> 01:00:15,000
[סטודנטים] מדוע לא יסתיים + להתחיל?

847
01:00:15,000 --> 01:00:17,000
למה זה לא יסתיים + להתחיל?

848
01:00:17,000 --> 01:00:19,000
[סטודנטים] למה זה לא כך?

849
01:00:19,000 --> 01:00:24,000
למה שזה יהיה +?

850
01:00:24,000 --> 01:00:26,000
אני חושב שאתה צודק.

851
01:00:26,000 --> 01:00:28,000
[סטודנטים] כי זה ממוצע?

852
01:00:28,000 --> 01:00:31,000
[נייט] סיום + להתחיל, את לגמרי נכון.

853
01:00:31,000 --> 01:00:34,000
וואו, אני לגמרי פשלתי. אתה צודק.

854
01:00:34,000 --> 01:00:39,000
אם היינו עושים פחות, הייתי רוצה להוסיף את מתחיל בחזרה פנימה

855
01:00:39,000 --> 01:00:43,000
במקרה זה, שאתה מאוד נכון שאנחנו רוצים לקחת את הממוצע של שניים,

856
01:00:43,000 --> 01:00:45,000
אז אל רוצים להוסיף אותם, בניגוד ללחסר אותם.

857
01:00:45,000 --> 01:00:49,000
[סטודנטים] זה גם הייתי עובד אם הייתי עושה סוף - מתחילים / 2 + להתחיל.

858
01:00:49,000 --> 01:00:55,000
אראה, אם אנחנו עושים, אני מאמינים שכן.

859
01:00:55,000 --> 01:01:00,000
>> לדוגמה, אם אנחנו מסתכלים להתחיל,

860
01:01:00,000 --> 01:01:04,000
ואנחנו עברנו על זה כאן

861
01:01:04,000 --> 01:01:08,000
ל15.

862
01:01:08,000 --> 01:01:12,000
עכשיו מתחילים הוא בעמדה 2.

863
01:01:12,000 --> 01:01:15,000
סיום הוא בעמדה 7.

864
01:01:15,000 --> 01:01:21,000
אם נתעלמתי מהם, אנחנו מקבלים 5.

865
01:01:21,000 --> 01:01:24,000
מחלק כי על ידי 2, אנחנו מקבלים 2.

866
01:01:24,000 --> 01:01:27,000
ואז להוסיף 2 בחזרה,

867
01:01:27,000 --> 01:01:30,000
וזה מביא אותנו לעמדה 4,

868
01:01:30,000 --> 01:01:33,000
שנמצא ממש כאן, שהוא נקודת האמצע.

869
01:01:33,000 --> 01:01:36,000
[סטודנטים] האם אנחנו צריכים לדאוג לעטיפה?

870
01:01:36,000 --> 01:01:39,000
באיזה מובנת אנחנו צריכים לדאוג לעטיפה?

871
01:01:39,000 --> 01:01:43,000
אם הסכום או את ההבדל בין

872
01:01:43,000 --> 01:01:45,000
תלויה איך אנחנו עושים את זה הוא לא מספר זוגי.

873
01:01:45,000 --> 01:01:49,000
אז המחשב מתבלבל אם כאשר זה 2.5;

874
01:01:49,000 --> 01:01:52,000
אתה לעבור לשמאל או לימין כדי לקבוע אילו הוא נקודת האמצע?

875
01:01:52,000 --> 01:01:54,000
קבל אותו.

876
01:01:54,000 --> 01:01:56,000
מתברר שעם חטיבה שלמה,

877
01:01:56,000 --> 01:01:59,000
אנחנו אף פעם לא מקבלים מספרי הנקודה צפו אלה.

878
01:01:59,000 --> 01:02:01,000
אנחנו אף פעם לא מקבלים העשרוניים.

879
01:02:01,000 --> 01:02:04,000
זה נזרק לחלוטין.

880
01:02:04,000 --> 01:02:08,000
אם יש לך מחשב לחלק את שני משתני int,

881
01:02:08,000 --> 01:02:11,000
ואחת הוא 7, והשני הוא 2,

882
01:02:11,000 --> 01:02:13,000
אתה לא תקבל 3.5 כתוצאה מכך.

883
01:02:13,000 --> 01:02:16,000
הוא יקבל 3.

884
01:02:16,000 --> 01:02:19,000
היתרה תימחק, כך שזה למעשה עיגול

885
01:02:19,000 --> 01:02:24,000
לא עגול אלא רצפה, אם אתם מכירים שבמתמטיקה,

886
01:02:24,000 --> 01:02:27,000
שבו אתה זורק עשרוני לחלוטין,

887
01:02:27,000 --> 01:02:31,000
ואז אתה בעצם מקצר אותו למוקד

888
01:02:31,000 --> 01:02:33,000
כל עמדה, למספר השלם הקרוב ביותר.

889
01:02:33,000 --> 01:02:38,000
[סטודנטים] אבל אז זה בעייתי, כי אם יש לך מערך של 7 אלמנטים

890
01:02:38,000 --> 01:02:43,000
אז באופן אוטומטי שלוקח את האלמנט 3 מתוך נקודת אמצע במקום 4.

891
01:02:43,000 --> 01:02:46,000
איך מתמודדים עם זה?

892
01:02:46,000 --> 01:02:49,000
זה בעייתי, כי אם היה לנו מערך של 7,

893
01:02:49,000 --> 01:02:54,000
זה יהיה לאסוף 3 במקום 4.

894
01:02:54,000 --> 01:02:56,000
אתה יכול להסביר קצת יותר?

895
01:02:56,000 --> 01:02:59,000
[סטודנטים] כי אם יש לך 7 אלמנטים אז אלמנט 4

896
01:02:59,000 --> 01:03:04,000
יהיה נקודת האמצע, נכון?

897
01:03:04,000 --> 01:03:07,000
זכור את התגובה שלך על להיות אפס באינדקס, אם כי.

898
01:03:07,000 --> 01:03:10,000
[סטודנטים] כן, אז בעמדה 3. זה יהיה נקודת האמצע.

899
01:03:10,000 --> 01:03:12,000
כן.

900
01:03:12,000 --> 01:03:16,000
אה, אוקיי. אני מבין למה אתה מתכוון.

901
01:03:16,000 --> 01:03:19,000
זה קצת מוזר, כמו שאנחנו מתרגלים לכל הרעיון הזה של

902
01:03:19,000 --> 01:03:22,000
להיפטר משברים עשרוניים.

903
01:03:22,000 --> 01:03:26,000
זו נקודה מצוינת.

904
01:03:26,000 --> 01:03:30,000
בואו נסיים את זה.

905
01:03:30,000 --> 01:03:32,000
חשבנו נקודת האמצע שלנו.

906
01:03:32,000 --> 01:03:37,000
>> אנחנו בודקים כדי לראות אם המחט שלנו שווה לערך האמצעי.

907
01:03:37,000 --> 01:03:41,000
אנחנו מדפיסים שמצאנו אותו, אבל באמת, מה אנחנו רוצים לעשות במצב כזה?

908
01:03:41,000 --> 01:03:46,000
אנחנו כבר מצאנו את זה, ולכן אנחנו רוצים לתת למתקשר לדעת שמצאנו אותה.

909
01:03:46,000 --> 01:03:49,000
יש לנו תפקיד זה פונקציה שהוקלדה בוליאני.

910
01:03:49,000 --> 01:03:54,000
הדרך בה אנו לאותת למתקשר של הפונקציה שלנו שאנחנו מוכנים ללכת

911
01:03:54,000 --> 01:03:58,000
הוא שאנו אומרים, "היי, זה נכון."

912
01:03:58,000 --> 01:04:00,000
איך הייתי עושה את זה, קווין?

913
01:04:00,000 --> 01:04:02,000
אתה מהנהן בראש שלך. >> שיבה [קווין] הוסף אמיתי.

914
01:04:02,000 --> 01:04:06,000
[נייט] בדיוק, החזר אמיתי.

915
01:04:06,000 --> 01:04:12,000
עכשיו, אם זה לא שווה, איך אנו מסתכלים על המחצית השמאלית?

916
01:04:12,000 --> 01:04:16,000
יש לך רעיונות?

917
01:04:16,000 --> 01:04:18,000
סטלה, לך רעיונות?

918
01:04:18,000 --> 01:04:21,000
אתה צריך להגדיר מיקום חדש לסוף.

919
01:04:21,000 --> 01:04:23,000
כן.

920
01:04:23,000 --> 01:04:29,000
אז יש לנו לעשות עמדה של אמצע - הסוף.

921
01:04:29,000 --> 01:04:33,000
גדול.

922
01:04:33,000 --> 01:04:36,000
אנחנו צריכים לקבוע עמדה חדשה לסיום

923
01:04:36,000 --> 01:04:38,000
להסתכל על חיצו השמאלי.

924
01:04:38,000 --> 01:04:41,000
זה היה על מה דבר לפני שבו

925
01:04:41,000 --> 01:04:44,000
אני ממשיך לחזור לדוגמה זו.

926
01:04:44,000 --> 01:04:50,000
אני אתחיל כאן, ואז יש לי בסוף כל הדרך לכאן.

927
01:04:50,000 --> 01:04:53,000
>> שוב, אם אנחנו מחפשים 15, ונקודת האמצע שלנו היא בגיל 16,

928
01:04:53,000 --> 01:04:56,000
ואנחנו מבינים, "אופס, 16 הם גדולים יותר.

929
01:04:56,000 --> 01:04:59,000
אנחנו רוצים לעבור לצד שמאל. "

930
01:04:59,000 --> 01:05:02,000
הייתי אז להעביר את הסוף ל15,

931
01:05:02,000 --> 01:05:06,000
ואנחנו עושים את זה על ידי לקחת את אחד מנקודת האמצע

932
01:05:06,000 --> 01:05:09,000
וקביעה כי כסיום החדש שלנו.

933
01:05:09,000 --> 01:05:12,000
כמו כן, אם אנחנו רוצים להסתכל על החץ ימינה, איך אנחנו עושים את זה?

934
01:05:12,000 --> 01:05:14,000
האם יש לך רעיון?

935
01:05:14,000 --> 01:05:22,000
[סטודנטים] אתה פשוט להגדיר מתחיל אמצע + 1.

936
01:05:22,000 --> 01:05:24,000
[נייט] גדול.

937
01:05:24,000 --> 01:05:29,000
ועכשיו במקרה שאנחנו לא מוצאים שום דבר,

938
01:05:29,000 --> 01:05:32,000
זה מביא את לטפל בכך עבורנו?

939
01:05:32,000 --> 01:05:36,000
דניאל, זה מביא את המטופל ל?

940
01:05:36,000 --> 01:05:38,000
[דניאל] מס

941
01:05:38,000 --> 01:05:40,000
[נייט] אם אנחנו עושים את זה דרך כל המערך ואנחנו לא מוצאים שום דבר,

942
01:05:40,000 --> 01:05:42,000
איפה הייתי שאטופל, או שעל לטפל בזה?

943
01:05:42,000 --> 01:05:44,000
[דניאל] המצב בזמן.

944
01:05:44,000 --> 01:05:48,000
[נייט] כן, המצב בזמן, בדיוק.

945
01:05:48,000 --> 01:05:51,000
זה ידאג לעובר כל המערך אם אנחנו לא מוצאים שום דבר.

946
01:05:51,000 --> 01:05:53,000
לולאה בזמן זה תסתיים.

947
01:05:53,000 --> 01:05:56,000
אנחנו לעולם לא נתקלנו במצב זה,

948
01:05:56,000 --> 01:06:03,000
ואנחנו יכולים לחזור שווא.

949
01:06:03,000 --> 01:06:10,000
אנחנו גם יכולים להשאיר את זה, אם כך לכאן

950
01:06:10,000 --> 01:06:14,000
כי אם זה אם הטענה נכונה,

951
01:06:14,000 --> 01:06:16,000
והפונקציה שלנו תחזור,

952
01:06:16,000 --> 01:06:21,000
ואז אנחנו בעצם להפיל זה פונקציה בנקודה זו

953
01:06:21,000 --> 01:06:24,000
כשנחזור נכון.

954
01:06:24,000 --> 01:06:28,000
אבל מה קורה עם המבנה הזה כאן?

955
01:06:28,000 --> 01:06:34,000
האם זה עובד לחלוטין, או שיש איזה פגם לוגי שם?

956
01:06:34,000 --> 01:06:37,000
>> יש איזה פגם לוגי לשם, בדרך שבה הם מאורגנים.

957
01:06:37,000 --> 01:06:40,000
מה יכול להיות?

958
01:06:40,000 --> 01:06:43,000
[סטודנטים] למה אתה צריך - ו+ 1s?

959
01:06:43,000 --> 01:06:47,000
שמגדיר המערך שלנו עד למחצית השמאלית שלנו החדשה והחצי נכון.

960
01:06:47,000 --> 01:06:51,000
[סטודנטים] אבל למה לא יכל לעשות את זה בלי - 1s ו+ 1s?

961
01:06:51,000 --> 01:06:53,000
[נייט] אנו יכולים להגדיר אותו שווים לנקודת האמצע?

962
01:06:53,000 --> 01:07:04,000
מה יכול להיות בעייתי בזה?

963
01:07:04,000 --> 01:07:08,000
[סטודנטים] אני מניח שזה לא יעיל, כי אתה בודק ערך שכבר בדק.

964
01:07:08,000 --> 01:07:11,000
[נייט] בדיוק, כדי שסם הוא לגמרי נכון.

965
01:07:11,000 --> 01:07:15,000
אם תגדיר את הסוף ומתחיל שווה לנקודת האמצע

966
01:07:15,000 --> 01:07:18,000
במקום - 1 + 1 ומהורהר,

967
01:07:18,000 --> 01:07:22,000
בשלב מסוים בעתיד, בסוף עוד בדיקת האמצע שוב.

968
01:07:22,000 --> 01:07:26,000
[סטודנטים] התחלתי pset, ולאחר מכן היה לי משהו כזה

969
01:07:26,000 --> 01:07:30,000
איפה שכחתי + 1, והוא היה נתקע בלולאה אינסופית.

970
01:07:30,000 --> 01:07:34,000
נכון, כי בשלב מסוים אתה לא הולך לקבל מתחיל ומסתיים

971
01:07:34,000 --> 01:07:39,000
למעשה חופף.

972
01:07:39,000 --> 01:07:41,000
מגניב.

973
01:07:41,000 --> 01:07:44,000
יש פגם לוגי אחד יותר, וזה שזה בהחלט צריך להיות

974
01:07:44,000 --> 01:07:48,000
אם אחר.

975
01:07:48,000 --> 01:07:55,000
למה זה יכול להיות?

976
01:07:55,000 --> 01:07:59,000
>> הסיבה היא שאם זה לא אחר אם לא, אתה רואה את זה, קווין?

977
01:07:59,000 --> 01:08:02,000
[קווין] כן, כי אתה משנה את נקודת הסיום.

978
01:08:02,000 --> 01:08:05,000
[נייט] בדיוק.

979
01:08:05,000 --> 01:08:07,000
אנחנו משנים את נקודת הסיום,

980
01:08:07,000 --> 01:08:12,000
ואם זה כתוב כמו להכין מזה לעשות רווחים בין

981
01:08:12,000 --> 01:08:14,000
זה יהיה לבדוק את המקרה הזה.

982
01:08:14,000 --> 01:08:18,000
במקרה זה, אם היא תצליח, יצא להפלה של הפונקציה.

983
01:08:18,000 --> 01:08:21,000
ואז זה יהיה לבדוק המקרה הבא,

984
01:08:21,000 --> 01:08:24,000
ואם זה יצליח, זה יהיה להתאים את נקודת הסיום,

985
01:08:24,000 --> 01:08:28,000
ואז זה ימשיך הלאה ולבדוק מקרה זה.

986
01:08:28,000 --> 01:08:31,000
אך בשלב זה, אנחנו לא רוצים שזה ימשיך לבדוק.

987
01:08:31,000 --> 01:08:35,000
למרבה המזל, יש לנו לא לאפס את נקודת האמצע כאן,

988
01:08:35,000 --> 01:08:39,000
ואנחנו יודעים שמקרה זה לא יצליח.

989
01:08:39,000 --> 01:08:44,000
אבל אנחנו בהחלט רוצים לשים אחרים אם יש ב

990
01:08:44,000 --> 01:08:48,000
למרות שאולי במקרה הזה,

991
01:08:48,000 --> 01:08:52,000
מאז אנחנו לא התאמנו את נקודת אמצע, מה זה משנה?

992
01:08:52,000 --> 01:08:54,000
לא, משום שמקרים אלה הם כל בלעדיים.

993
01:08:54,000 --> 01:08:58,000
שוב, שלי רע.

994
01:08:58,000 --> 01:09:01,000
אנחנו לא, אני חושב, צריכים אחר זה אם.

995
01:09:01,000 --> 01:09:05,000
אנחנו יכולים לתת לו לנסות ולהפעיל אותו ולראות מה קורה.

996
01:09:05,000 --> 01:09:08,000
בניין, אירע שגיאה.

997
01:09:08,000 --> 01:09:12,000
זה כנראה בגלל שהשארתי אותם ב של דואר ושל כאן.

998
01:09:12,000 --> 01:09:14,000
האם יש לי יותר מאלו למעלה בחלק העליון?

999
01:09:14,000 --> 01:09:16,000
זה לא נראה כמותו.

1000
01:09:16,000 --> 01:09:20,000
אנו להתרחק, לבנות,

1001
01:09:20,000 --> 01:09:24,000
שם זה הולך, אז עכשיו אם תחפש ל15,

1002
01:09:24,000 --> 01:09:28,000
כן.

1003
01:09:28,000 --> 01:09:30,000
בואו להתקרב פנימה

1004
01:09:30,000 --> 01:09:33,000
15, כן. אנחנו יכולים להפעיל אותו שוב.

1005
01:09:33,000 --> 01:09:36,000
מעלה את קוד מקור, בנייה, הפעלה.

1006
01:09:36,000 --> 01:09:41,000
אנחנו יכולים לחפש משהו כמו 13,

1007
01:09:41,000 --> 01:09:45,000
ואנחנו לא מקבלים שום דבר בהדפסה, כך שזה לא מוצא את זה בשבילנו.

1008
01:09:45,000 --> 01:09:51,000
זה נהדר, כי זה לא ברשימה שלנו.

1009
01:09:51,000 --> 01:09:53,000
>> אנו נמצאים כעת מחוץ לזמן.

1010
01:09:53,000 --> 01:09:55,000
זה הולך להיות אותו לשבוע הזה.

1011
01:09:55,000 --> 01:10:00,000
תודה שהצטרף, ולראות אותך מאוחר יותר.

1012
01:10:00,000 --> 01:10:02,000
>> [CS50.TV]