1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,640
ZAMYLA CHAN: זהו-לי, Zamyla.

3
00:00:02,640 --> 00:00:06,950
היום, אנחנו הולכים ליישם
מריו, שבו אנו מפנים את מריו

4
00:00:06,950 --> 00:00:10,730
פירמידה מלאה בשבילו כדי לקפוץ מעל.

5
00:00:10,730 --> 00:00:14,430
בואו לשבור את
תת משימות עבור בעיה זו.

6
00:00:14,430 --> 00:00:17,930
>> ראשית, אנחנו רוצים להציג למשתמש
עבור גובה הפירמידה.

7
00:00:17,930 --> 00:00:20,510
ואז אנחנו רוצים לוודא
כי קלט כי הוא תקף.

8
00:00:20,510 --> 00:00:23,280
ואז אנחנו הולכים
רוצה לצייר את הפירמידה.

9
00:00:23,280 --> 00:00:26,850
>> אז בואו נדבר על מה שגרם
ואימות קלט משתמש.

10
00:00:26,850 --> 00:00:29,920
זה עשוי להיראות משהו כמו
זה, לולאת while מטלות כי

11
00:00:29,920 --> 00:00:33,250
מציג למשתמש עבור
חוזר שלם וגם אז רק

12
00:00:33,250 --> 00:00:35,700
אם מספר שלם שאינו חוקי.

13
00:00:35,700 --> 00:00:38,220
אז מה צריך את המצב הזה להיות?

14
00:00:38,220 --> 00:00:40,630
>> לשם כך, בואו נחזור
למפרט.

15
00:00:40,630 --> 00:00:46,240
ובכן, המפרט אומר לנו שכל חוקי
גובה הולך להיות בין 0 ל -23,

16
00:00:46,240 --> 00:00:47,350
כָּלוּל.

17
00:00:47,350 --> 00:00:51,400
אז זה אומר שכל חוקי
גובה הולך להיות פחות מ 0

18
00:00:51,400 --> 00:00:53,840
או יותר מ -23.

19
00:00:53,840 --> 00:00:57,220
>> אז עכשיו שיש לנו את המידע הזה,
בואו לעצב מצבנו.

20
00:00:57,220 --> 00:00:59,230
אבל אנחנו צריכים להיות זהירים,
כי עכשיו יש לנו

21
00:00:59,230 --> 00:01:02,130
שני Booleans שאנחנו רוצים להעריך.

22
00:01:02,130 --> 00:01:04,150
>> כאן סיפקתי לך
עם שולחן אמת.

23
00:01:04,150 --> 00:01:07,520
זה מאפשר לנו לקחת שני
Booleans, בוליאני אחד ושני.

24
00:01:07,520 --> 00:01:13,600
ואנחנו יכולים להעריך או bool1
ו bool2 או bool1 או bool2.

25
00:01:13,600 --> 00:01:17,390
>> אז מה ההבדל
בין לבין ו או?

26
00:01:17,390 --> 00:01:21,810
ובכן, bool1 ו bool2 יהיה
להעריך כאמת אם ורק

27
00:01:21,810 --> 00:01:25,680
אם הן Booleans נכון,
ואילו או בהפעלתה

28
00:01:25,680 --> 00:01:30,190
יהיה נכון אם של אחד מהם
Booleans או שניהם נכונים.

29
00:01:30,190 --> 00:01:33,110
אז עם זה בחשבון,
לראות אם אתה יכול להבין

30
00:01:33,110 --> 00:01:37,460
מה מצבו המתאים
הלולאה עשה בזמן שלך עבור n חוקי

31
00:01:37,460 --> 00:01:38,850
זה הולך להיות.

32
00:01:38,850 --> 00:01:43,540
>> עם זאת, אנו פועלים מתבקשים ומאומתים
המשתמש עבור גובה הפירמידה

33
00:01:43,540 --> 00:01:44,550
כי הם רוצים.

34
00:01:44,550 --> 00:01:47,740
אז עכשיו, זה תלוי בנו
לצייר הפירמידה.

35
00:01:47,740 --> 00:01:50,520
הפירמידה המלאה לכך
בעיה תיראה קצת

36
00:01:50,520 --> 00:01:56,340
ככה, יש לנו שם פירמידת שמאל,
כמה פער, ולאחר מכן פירמידה תקינה.

37
00:01:56,340 --> 00:01:58,630
אז בואו לשבור את זה למטה קצת.

38
00:01:58,630 --> 00:02:03,510
>> אם אלך עורך הטקסט שלי, כאן אין לי
נמשך לנו פירמידה מזדהה שמאל.

39
00:02:03,510 --> 00:02:05,160
אבל זה לא יעשה.

40
00:02:05,160 --> 00:02:10,139
מה שאנחנו רוצים לעשות הוא שאנחנו רוצים
ליצור פירמידה מיושרת לימין ראשון.

41
00:02:10,139 --> 00:02:13,580
אז כדי לעשות את זה, פשוט לדחוף
hashes שלי יחד לצד,

42
00:02:13,580 --> 00:02:18,240
אני רק הולך לשים כמה תווים
בין לבין, רק הנקודות הללו.

43
00:02:18,240 --> 00:02:22,560
אז אני הולך לשים שתי על
השורה הבאה, ואחד על הקו.

44
00:02:22,560 --> 00:02:26,070
אז הנה יש לי
מיושר לימין הפירמידה.

45
00:02:26,070 --> 00:02:28,540
>> אחרי זה, אני הולך
לחזור בשורה העליונה

46
00:02:28,540 --> 00:02:33,930
ולשים את הפער, אשר
הוא, על פי המפרט, שני חללים.

47
00:02:33,930 --> 00:02:37,680
אז אני הולך למלא את
הצד השני של הפירמידה.

48
00:02:37,680 --> 00:02:42,030
אני הולך ללכת בשורה השנייה, לכתוב
שני חללים לפער ולאחר מכן שני

49
00:02:42,030 --> 00:02:42,920
hashes.

50
00:02:42,920 --> 00:02:47,020
חזרה בשורה השלישית, שני חללים
לפער ושלושה אלגוריתמי Hash.

51
00:02:47,020 --> 00:02:51,480
ובסוף, שני חללים
לפער וארבעה אלגוריתמי Hash.

52
00:02:51,480 --> 00:02:54,400
אז זה מה מלא
פירמידה תיראה.

53
00:02:54,400 --> 00:02:57,260
>> כמובן, אנחנו לא רוצים
נקודות אלו בדרך.

54
00:02:57,260 --> 00:03:01,220
אז אנחנו הולכים להחליף את אלה
נקודות על ידי צבת קצת רווחים.

55
00:03:01,220 --> 00:03:03,720
אחת, שתיים, שלוש בשורה הראשונה.

56
00:03:03,720 --> 00:03:05,650
אחת, שתיים על השני.

57
00:03:05,650 --> 00:03:08,200
ואחד על השורה השלישית.

58
00:03:08,200 --> 00:03:12,060
אז זה מה היינו עושים אם אנחנו
רציתי רק לעשות פירמידה מלאה,

59
00:03:12,060 --> 00:03:13,700
אומרים, בעורך הטקסט שלנו.

60
00:03:13,700 --> 00:03:15,860
>> אז בואו ניקח את זה,
הבנת הדפוסים,

61
00:03:15,860 --> 00:03:19,870
ולהמיר אותו אל כמה פסאודו קוד.

62
00:03:19,870 --> 00:03:24,500
עבור כל שורה של הפירמידה, אנחנו רוצים
להדפיס הפירמידה שמאלה ואחר כך

63
00:03:24,500 --> 00:03:26,580
הפער ואז הפירמידה התקינה.

64
00:03:26,580 --> 00:03:30,260
עבור פירמידת השמאל, נדפיס
כמות המקומות הנדרשת,

65
00:03:30,260 --> 00:03:31,740
ואחריו ה- Hash.

66
00:03:31,740 --> 00:03:35,030
אז אנחנו להדפיס את הפער, אשר
הוא רק שני מקומות בכל פעם.

67
00:03:35,030 --> 00:03:38,080
וגם הפירמידה צודקת, אנחנו להדפיס
מספר hashes הנדרש.

68
00:03:38,080 --> 00:03:41,410
>> לקבלה בשורה השנייה, ערכנו
באותו התהליך המדויק.

69
00:03:41,410 --> 00:03:44,510
אנו מדפיסים את החללים לשמאל
פירמידה, נחיצות הכמות

70
00:03:44,510 --> 00:03:49,930
של Hash, הפער, שני חללים, ו
אז ה- Hash עבור הפירמידה התקינה.

71
00:03:49,930 --> 00:03:52,490
>> בואו להתמודד הדפוס
עבור פירמידת השמאל.

72
00:03:52,490 --> 00:03:55,660
אם היה לי, למטרות
דוגמה זו, לגובה

73
00:03:55,660 --> 00:03:58,790
שמונה מבוקש על ידי
משתמשים, אז בשורה הראשונה שלי

74
00:03:58,790 --> 00:04:01,020
יצטרך חשיש אחד ושבעה חללים.

75
00:04:01,020 --> 00:04:03,860
בשורה השנייה שלי תצטרך
שני אלגוריתמים Hash, שישה מקומות.

76
00:04:03,860 --> 00:04:06,749
שורה שלישית, שלוש hashes, חמישה מקומות.

77
00:04:06,749 --> 00:04:09,040
אתה בטח יכול לעשות את זה
עצמך לגובה של שמונה

78
00:04:09,040 --> 00:04:13,470
ולקבוע עבור כל שורה כמה
hashes וכמה מקומות שאתה צריך.

79
00:04:13,470 --> 00:04:16,209
אבל מה שאנחנו רוצים לעשות הוא
אנחנו רוצים מופשט זה.

80
00:04:16,209 --> 00:04:22,660
אז אני שואל אותך לכל שורה המי יודע כמה, כמה
hashes וכמה מקומות אנחנו צריכים?

81
00:04:22,660 --> 00:04:25,410
>> עכשיו, כפי שאתה לקבוע את
דפוס ולכמה hashes רב

82
00:04:25,410 --> 00:04:29,920
וכמה מקומות שאתה צריך בשביל
כל שורה המי יודע כמה על גובה נתון,

83
00:04:29,920 --> 00:04:32,910
לזכור להיזהר
איך אתה לאינדקס.

84
00:04:32,910 --> 00:04:37,160
לפי מה שאני אומר זה הוא כי כל יום
חיים רובנו מתחילים לספור על ידי אחד.

85
00:04:37,160 --> 00:04:39,680
אז בשורה הראשונה תהיה מספר אחת.

86
00:04:39,680 --> 00:04:43,620
וגם בשורה השנייה תהיה בשורה
מספר שתיים, הלאה וכן הלאה.

87
00:04:43,620 --> 00:04:47,620
>> אבל במדעי המחשב
CS50, אנחנו אפס צמודים.

88
00:04:47,620 --> 00:04:50,750
אז אנחנו בעצם מתחילים לספור על אפס.

89
00:04:50,750 --> 00:04:54,020
אז בשורה הראשונה הייתה
בשורה להיות מספר אפס.

90
00:04:54,020 --> 00:04:56,640
וגם בשורה השנייה
יהיה בשורה מספר אחד.

91
00:04:56,640 --> 00:05:02,510
אז אם היה לי לגובה של שמונה עבור
הפירמידה שלי, אז הערך האחרון של n

92
00:05:02,510 --> 00:05:05,850
למעשה יהיה שבע ולא שמונה.

93
00:05:05,850 --> 00:05:07,010
>> אז להיות זהירים לגבי זה.

94
00:05:07,010 --> 00:05:10,750
ולהיות מודע כשאתה קביעה
הדפוס שלך אם אפס צמודות שלך

95
00:05:10,750 --> 00:05:12,360
או אחד צמודות

96
00:05:12,360 --> 00:05:13,070
>> בסדר.

97
00:05:13,070 --> 00:05:15,380
אז עכשיו שיש לנו את
דפוס עבור פירמידת השמאל,

98
00:05:15,380 --> 00:05:18,650
אנחנו צריכים לקבוע
התבנית לפער.

99
00:05:18,650 --> 00:05:20,480
למזלנו, זה ממש קל.

100
00:05:20,480 --> 00:05:22,690
זה פשוט תמיד שני חללים.

101
00:05:22,690 --> 00:05:25,240
>> אז עכשיו נתקדם התבנית הנכונה.

102
00:05:25,240 --> 00:05:27,220
השורה הראשונה תהיה חשיש אחד.

103
00:05:27,220 --> 00:05:28,640
בשורה השנייה, שני.

104
00:05:28,640 --> 00:05:29,530
שורה שלישית, שלוש.

105
00:05:29,530 --> 00:05:30,790
כן הלאה וכן הלאה.

106
00:05:30,790 --> 00:05:35,540
אז שוב, לקבוע עבור כל מופשטים
n וכל בגובה כמה hashes

107
00:05:35,540 --> 00:05:38,810
וכמה מקומות
צריכה בכל שורה.

108
00:05:38,810 --> 00:05:39,700
>> בסדר.

109
00:05:39,700 --> 00:05:45,050
כך אנו יודעים כי עבור כל שורה אנחנו
צריך לנהל איזה תהליך.

110
00:05:45,050 --> 00:05:46,600
איך אנחנו עושים את זה?

111
00:05:46,600 --> 00:05:50,440
ובכן, אנו משתמשים עבור מבנה הלולאה,
מורכב של אתחול,

112
00:05:50,440 --> 00:05:52,310
מצב, ועדכון.

113
00:05:52,310 --> 00:05:54,830
לקבלת ניתן להשתמש לולאות
לחזור על תהליכים.

114
00:05:54,830 --> 00:05:59,610
>> אז להגיד שאני רוצה את זה כדי לומר שלום,
50 פעמים בעולם, אז שלי עבור לולאה

115
00:05:59,610 --> 00:06:03,510
היה נראה משהו כזה, שבו
אני לאתחל משתנה שלי ירדה לאפס.

116
00:06:03,510 --> 00:06:06,200
התנאי הוא כי אני הוא פחות מ -50.

117
00:06:06,200 --> 00:06:09,670
ואז העדכון הוא שהיא
התוספות אחד בכל פעם.

118
00:06:09,670 --> 00:06:14,700
אז מה זה יעשה יהיה
להדפיס שלום, עולם 50 פעמים ברציפות.

119
00:06:14,700 --> 00:06:18,080
>> עכשיו, נגיד שאני רוצה לחזר
על הגובה של הפירמידה.

120
00:06:18,080 --> 00:06:21,560
אז במקום קידוד קשה
כמה ערך במצבו,

121
00:06:21,560 --> 00:06:23,280
אני פשוט להשתמש הגובה המשתנה.

122
00:06:23,280 --> 00:06:27,180
אז מה זה יעשה הוא לחזר
על הגובה בכל שורה.

123
00:06:27,180 --> 00:06:30,280
ואני יכול לעשות משהו בפנים
של הגוף של לולאה זה.

124
00:06:30,280 --> 00:06:32,710
>> מה אנחנו רוצים לעשות
בתוך הגוף של הלולאה?

125
00:06:32,710 --> 00:06:36,550
ובכן, כפי שצוין קודם לכן, אנחנו רוצים
להדפיס את החללים ואת hashes

126
00:06:36,550 --> 00:06:40,730
עבור הפירמידה שמאלה ולאחר מכן הדפסה
שני חללים ולאחר מכן להדפיס את אלגוריתמי Hash.

127
00:06:40,730 --> 00:06:42,500
אז אנחנו כבר הבנו את זה.

128
00:06:42,500 --> 00:06:45,670
אז אנחנו יכולים להתחיל למלא
בתוכנית שלנו הרבה יותר.

129
00:06:45,670 --> 00:06:49,850
>> כאן יש לי חיצוני עבור לולאה
סובב על כל שורה בפירמידה.

130
00:06:49,850 --> 00:06:53,340
ובתוך הגוף כי אני הולך
להדפיס רווחים שוב ושוב,

131
00:06:53,340 --> 00:06:56,860
hashes שוב ושוב, ולאחר מכן את הפער,
ואז hashes עבור הפירמידה התקינה,

132
00:06:56,860 --> 00:07:00,440
ואז, סוף סוף, חדש
בתור כדי להתחיל את השורה הבאה.

133
00:07:00,440 --> 00:07:02,860
>> עם זאת, אנו פועלים נתבקש
המשתמש עבור הקלט.

134
00:07:02,860 --> 00:07:04,510
ביצענו בטוח שזה חוקי.

135
00:07:04,510 --> 00:07:06,280
ואז אנחנו שציירנו הפירמידה.

136
00:07:06,280 --> 00:07:09,540
אז מריו מצליח
לטפס על הפירמידה.

137
00:07:09,540 --> 00:07:10,970
>> שמי Zamyla.

138
00:07:10,970 --> 00:07:13,840
וזה CS50.

139
00:07:13,840 --> 00:07:15,419