1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [Walkthrough - סט בעיה 2]

2
00:00:01,940 --> 00:00:04,130
[Zamyla צ'אן - אוניברסיטת הרווארד]

3
00:00:05,170 --> 00:00:07,490
[זה CS50. CS50.TV]

4
00:00:07,490 --> 00:00:10,750
בסדר. שלום לכולם, וברוך הבאים לWalkthrough 2.

5
00:00:10,750 --> 00:00:14,330
ראשית, אני רוצה לברך אותך לגמר 1 pset.

6
00:00:14,330 --> 00:00:18,140
אני יודע שזה היה יכול להיות קצת קשה עבור חלק מכם,

7
00:00:18,140 --> 00:00:20,460
היה יכול להיות תכנית המחשב הראשונה שלך שאתה כתבת,

8
00:00:20,460 --> 00:00:24,500
אבל רק לזכור כי בסופו של זה, כשאתה מסתכל אחורה בסוף הסמסטר,

9
00:00:24,500 --> 00:00:29,820
אתה מסתכל 1 pset ואתה אומר, "היי, אני יכול לעשות את זה ב 5 דקות."

10
00:00:29,820 --> 00:00:35,700
אז מכיר ובוטח שבסופו של זה תוכל בהחלט למצוא pset 1 די פשוט.

11
00:00:35,700 --> 00:00:40,640
אבל לעת עתה זה הישג עצום, וברכות על המתבצעת.

12
00:00:40,640 --> 00:00:44,010
עכשיו, גם הערה מהירה לפני שאנחנו מקבלים את הבשר של ההדרכה.

13
00:00:44,010 --> 00:00:48,340
אני רק רוצה לעשות את הערה מהירה שלפעמים לא יהיה לי מספיק זמן

14
00:00:48,340 --> 00:00:52,500
במהלך ההדרכות לעבור כל דרך יחידה לעשות סט הבעיה

15
00:00:52,500 --> 00:00:56,140
ולא רק אולי להתמקד בסוג 1 או 2 של מימושים,

16
00:00:56,140 --> 00:00:57,750
דרכים שאתה יכול לעשות את זה.

17
00:00:57,750 --> 00:01:01,970
אבל זה לא אומר שאסור מלעשות את זה בדרך אחרת.

18
00:01:01,970 --> 00:01:05,980
לעתים קרובות יש, כמו במדע המחשב, דרכים רבות לעשיית דברים,

19
00:01:05,980 --> 00:01:12,190
וכך בהחלט מרגיש חופשי להשתמש בסוג אחר של פתרון ממה שאני יכול להיות מוצג.

20
00:01:12,190 --> 00:01:14,520
[Pset 2: אנוסים - Zamyla צ'אן - zamyla@cs50.net]

21
00:01:14,520 --> 00:01:17,160
[Pset2 - 0. סעיף של שאלות - 1. קיסר - 2. Vigenere]

22
00:01:17,160 --> 00:01:20,650
בסדר. אז הבעיה להגדיר 2: אנוסים הוא אחד מהנה.

23
00:01:20,650 --> 00:01:24,500
שוב, עם כל pset יתחיל עם קטע של שאלות

24
00:01:24,500 --> 00:01:29,600
זה הולך להיות שנערך בסעיפים שלך עם בחור ההוראה יוקצה לכם.

25
00:01:29,600 --> 00:01:31,670
אנחנו לא הולכים לעבור אלה על ההדרכה,

26
00:01:31,670 --> 00:01:35,100
אבל הם בהחלט יעזרו לך להשלים את pset.

27
00:01:35,100 --> 00:01:38,100
אז את החלק הראשון של סדרת הבעיה הוא קיסר.

28
00:01:38,100 --> 00:01:43,470
וכך בקיסר מישהו יעבור לך מפתח עם מספר שלם,

29
00:01:43,470 --> 00:01:48,420
ואתה להצפין מחרוזת הטקסט שהם מספקים לך

30
00:01:48,420 --> 00:01:50,670
ולתת להם בחזרה דבר מוצפן.

31
00:01:50,670 --> 00:01:56,050
אם מישהו ראה סיפור חג המולד, יש דוגמה של שיש.

32
00:01:56,050 --> 00:01:59,090
אז את החלק השני של סט הבעיה הוא Vigenere,

33
00:01:59,090 --> 00:02:01,790
שהיא טכניקת הצפנה מתקדמת יותר.

34
00:02:01,790 --> 00:02:05,640
וכך אנחנו הולכים בצופן קטע הטקסט,

35
00:02:05,640 --> 00:02:09,600
רק שבמקום רק עם אחת שלם, אנחנו באמת הולכים לקודד אותו

36
00:02:09,600 --> 00:02:13,340
עם מילת מפתח שהמשתמש יספק אותנו.

37
00:02:16,270 --> 00:02:22,090
אוקיי, אז הכלי הראשון בארגז הכלים של היום הוא בעצם הולך להיות עדכון המכשיר.

38
00:02:22,090 --> 00:02:26,430
בלוח הדיונים היינו רואים דברים כמו, "למה זה לא עובד?"

39
00:02:26,430 --> 00:02:28,110
"מדוע לא להגיש 50 עבודות?"

40
00:02:28,110 --> 00:02:31,830
ולעתים קרובות הפתרון הוא למעשה רק כדי לעדכן את המכשיר שלך.

41
00:02:31,830 --> 00:02:36,730
ואז אם רק תפעל בחלון מסוף sudo במכשיר שלך yum-y -

42
00:02:36,730 --> 00:02:40,040
זה דגל אומר כן, לעדכן הכל - עדכון,

43
00:02:40,040 --> 00:02:42,280
אז המכשיר שלך יעדכן אם יהיה בכך צורך.

44
00:02:42,280 --> 00:02:46,960
וזה לא כואב, אם אתה כבר נמצאת בגרסה העדכנית ביותר של המכשיר.

45
00:02:46,960 --> 00:02:51,280
אז זה פשוט יגיד אין עדכונים חדשים זמינים ותוכל להמשיך לעבוד יחד.

46
00:02:51,280 --> 00:02:55,800
אבל זה טוב לביצוע גם בכל פעם שאתה פותח את המכשיר

47
00:02:55,800 --> 00:02:57,140
בגלל שאנחנו עדיין מאוד -

48
00:02:57,140 --> 00:03:00,320
לפעמים אם אנחנו באים לבאג - לתקן את זה במכשיר.

49
00:03:00,320 --> 00:03:03,180
אז ודא שיש לך את הגרסה העדכנית ביותר של המכשיר

50
00:03:03,180 --> 00:03:07,710
ולהפעיל שאעדכן שם.

51
00:03:07,710 --> 00:03:14,360
בסדר. אז מכיוון שאנחנו עוסקים באותיות ובשינוי, enciphering דברים,

52
00:03:14,360 --> 00:03:20,410
אנחנו הולכים באמת רוצים להיות חברים הכי טובים עם תרשים ASCII שלנו.

53
00:03:20,410 --> 00:03:24,350
ישנם אלה רבים באינטרנט, אם אתה מוצא. אולי אפילו להפוך את עצמו.

54
00:03:24,350 --> 00:03:29,950
בעיקרון, עם כל מכתב וכל מספר וכל תו

55
00:03:29,950 --> 00:03:32,210
מקיים מספר המשויך אליהם,

56
00:03:32,210 --> 00:03:38,670
ולכן זה טוב לראות את ערכי ASCII שלהם יחד עם המכתב בפועל.

57
00:03:38,670 --> 00:03:42,310
זה בהחלט יעזור לך בסט הבעיה.

58
00:03:42,310 --> 00:03:45,750
דבר אחד שבאמת עזר לי בסט בעיה זו היה למעשה להדפיס אותו,

59
00:03:45,750 --> 00:03:48,380
וכמו שעברתי עליי, הייתי ממש לצייר על זה,

60
00:03:48,380 --> 00:03:51,150
לכתוב, "אם זה צריך ללכת לשם, אז ..."

61
00:03:51,150 --> 00:03:55,270
הסוג של לצייר על זה ולסמן אותו, הפך לחברים הטובים ביותר עם שולחן ASCII שלך.

62
00:03:57,240 --> 00:04:00,750
אז יש לנו כמה כלים אחרים העומדים לרשותנו.

63
00:04:00,750 --> 00:04:03,750
הפעם במקום באמת לשאול את המשתמש לכל הקלט שלהם

64
00:04:03,750 --> 00:04:05,230
אנחנו הולכים לעשות את שילוב.

65
00:04:05,230 --> 00:04:06,880
אנחנו הולכים כדי להנחות אותם לקלט כלשהו,

66
00:04:06,880 --> 00:04:11,350
אבל אנחנו גם הולכים רק כדי להשתמש בטיעוני שורת הפקודה.

67
00:04:11,350 --> 00:04:15,600
לכן, כאשר הם רצים התכנית שלהם, בדרך כלל שאתה אומר. / שלום, למשל,

68
00:04:15,600 --> 00:04:17,310
אם התכנית שלך הייתה hello.c.

69
00:04:17,310 --> 00:04:22,500
אך הפעם, במקום להסתפק באמירה שהם יכולים לשים את מילים, ויכוחים לאחר מכן.

70
00:04:22,500 --> 00:04:27,210
וכך אנחנו הולכים להשתמש בכל מה שהם עוברים אלינו כקלט שלהם, כמו גם,

71
00:04:27,210 --> 00:04:31,720
כל כך מרגש מעבר רק להציג עבור מספר שלם, אלא גם משתמש בנימוקים של שורת פקודה.

72
00:04:31,720 --> 00:04:36,590
ואז נלך למערכים ומחרוזות, שיהיה לנו באמצעות הרבה גם כן.

73
00:04:41,460 --> 00:04:44,810
הנה רק דוגמה לתרשים ASCII 1 מיני.

74
00:04:44,810 --> 00:04:48,460
כפי שאמרתי, כל אות מתאימה למספר,

75
00:04:48,460 --> 00:04:52,510
וכך להכיר את עצמך עם זה. זה יהיה שימושי.

76
00:04:52,510 --> 00:04:55,610
ומאוחר יותר, כאשר אנחנו מתחילים לעשות כמה ASCIIMath התמודדות עם מספרים -

77
00:04:55,610 --> 00:05:00,110
הוספה, חיבורם - אז בהחלט טוב להתייחס לטבלה זו.

78
00:05:02,860 --> 00:05:06,920
אז הנה דוגמה לצופן קיסר - משהו שאתה אולי שחקת ב.

79
00:05:06,920 --> 00:05:11,190
זה רק הגה. בעיקרו של דבר, יש האלפבית חיצוני ואז יש האלפבית פנימי.

80
00:05:11,190 --> 00:05:15,290
אז כאן הוא דוגמה לצופן הקיסר אבל עם מפתח של 0.

81
00:05:15,290 --> 00:05:21,540
בעיקרו של דבר, הוא מתואם עם A, B מיושר עם B, כל הדרך עד לז'

82
00:05:21,540 --> 00:05:26,590
אבל אז אומר שרצינו מפתח של 3, למשל.

83
00:05:26,590 --> 00:05:33,280
אז הייתי לסובב את הגלגל הפנימי כך שכעת מיישר עם ד ', וכו'

84
00:05:33,280 --> 00:05:35,250
ואז זה בעצם מה שאנחנו הולכים לעשות.

85
00:05:35,250 --> 00:05:38,340
אין לנו גלגל, אבל מה שאנחנו הולכים לעשות הוא להפוך את התכנית שלנו

86
00:05:38,340 --> 00:05:44,490
סוג של להעביר את האלפבית איתנו כמות מסוימת של מספרים.

87
00:05:44,490 --> 00:05:48,650
אז כמו שאמרתי קודם, אנחנו הולכים להיות התמודדות עם טיעוני שורת פקודה

88
00:05:48,650 --> 00:05:50,390
כמו גם מקבל מספר שלם.

89
00:05:50,390 --> 00:05:55,050
לכן הדרך שמשתמש יהיה להפעיל את התכנית שלך היא על ידי הקיסר אומר. / קיסר

90
00:05:55,050 --> 00:05:58,090
ולאחר מכן הזנת מספר לאחר מכן.

91
00:05:58,090 --> 00:06:01,130
והמספר שמייצג את המפתח, המשמרת,

92
00:06:01,130 --> 00:06:06,740
כמה פעמים אתה הולך להיות סיבוב הגלגל הפנימי של צופן הקיסר שלך.

93
00:06:06,740 --> 00:06:08,390
ואז אתה רואה כאן דוגמה.

94
00:06:08,390 --> 00:06:14,550
אם נכנסו למכתבים משמאל לצופן הקיסר שלנו,

95
00:06:14,550 --> 00:06:19,520
אז זה היית קלט D דרך O כי זה כל אות עברה מעל 3 פעמים,

96
00:06:19,520 --> 00:06:22,080
בדיוק כמו בדוגמא של הגלגל שהראיתי לך.

97
00:06:22,080 --> 00:06:25,300
אז אם אתה נכנסת, למשל, זה CS50!

98
00:06:25,300 --> 00:06:27,960
אז זה גם היה עובר את כל האותיות.

99
00:06:27,960 --> 00:06:31,040
וזה דבר חשוב הוא בקיסר וVigenere

100
00:06:31,040 --> 00:06:34,890
הוא שאנחנו הולכים לדלג על כל מי שאינם אותיות.

101
00:06:34,890 --> 00:06:39,160
אז את כל רווחים, תווים, וכו ', מספרים, אנחנו הולכים כדי לשמור אותם אותו הדבר.

102
00:06:39,160 --> 00:06:42,920
אנחנו רק הולכים להעביר את המכתבים במקרה זה.

103
00:06:42,920 --> 00:06:45,870
אז כפי שאתם רואים בגלגל, יש לנו את המכתבים לרשותנו בלבד,

104
00:06:45,870 --> 00:06:50,150
אז אנחנו רוצים רק להעביר את המכתבים ולהצפין את המכתבים.

105
00:06:51,370 --> 00:06:56,720
אז הדבר הראשון לעשות, אתה ראית שהשימוש לקיסר בבעיה להגדיר 2

106
00:06:56,720 --> 00:07:05,280
הוא להפעיל קיסר ולאחר מכן להזין את המספר כשאתה מפעיל אותו במסוף.

107
00:07:05,280 --> 00:07:10,940
אז מה שאנחנו צריכים לעשות זה איכשהו כדי לקבל את המפתח ושלגשת אליו.

108
00:07:10,940 --> 00:07:14,730
וכך אנחנו רוצים לראות את זה איכשהו הולך להיות ויכוח שורת הפקודה השנייה.

109
00:07:14,730 --> 00:07:20,950
הראשון הולך להיות. / קיסר, והבא הוא הולך להיות מספר המפתח.

110
00:07:22,190 --> 00:07:29,200
אז לפני שהיה לנו int (void) העיקרי להפעלת תוכניות C שלנו.

111
00:07:29,200 --> 00:07:31,790
אנחנו הולכים לקלף שכבה קצת

112
00:07:31,790 --> 00:07:34,720
וממש רואה שבמקום לעבור בחלל לפונקציה העיקרית שלנו

113
00:07:34,720 --> 00:07:37,920
אנו בעצם מתעסקים עם 2 פרמטרים.

114
00:07:37,920 --> 00:07:44,070
יש לנו בשם int argc ולאחר מכן מערך של מייתרים, הנקרא argv.

115
00:07:44,070 --> 00:07:46,030
אז argc הוא מספר שלם,

116
00:07:46,030 --> 00:07:49,640
והיא מייצגת את מספר הארגומנטים שמועברים לתכנית שלך.

117
00:07:49,640 --> 00:07:53,590
ואז argv הוא למעשה הרשימה של הטיעונים עברו.

118
00:07:53,590 --> 00:08:00,820
כל הטענות הן מחרוזות, וכך argv מייצג מערך, רשימה, של מחרוזות.

119
00:08:01,830 --> 00:08:03,990
בואו נדבר על מערכים קצת.

120
00:08:03,990 --> 00:08:05,940
מערכים הם בעצם מבנה נתונים חדש.

121
00:08:05,940 --> 00:08:09,660
יש לנו ints, יש לנו זוגות, יש לנו מייתרים, ועכשיו יש לנו מערכים.

122
00:08:09,660 --> 00:08:13,820
מערכים הם מבני נתונים שיכולים להכיל ערכים מרובים מאותו הסוג,

123
00:08:13,820 --> 00:08:18,320
כך למעשה, רשימה של כל סוג שאתה רוצה.

124
00:08:18,320 --> 00:08:24,400
בעיקרו של דבר, אם אתה רוצה רשימה של מספרים שלמים בכל משתנים 1,

125
00:08:24,400 --> 00:08:29,090
אז היית ליצור משתנה חדש שהיה של מערך הסוג int.

126
00:08:29,090 --> 00:08:34,450
אז מערכים הם אפס למדד, כלומר האלמנט הראשון של המערך הוא במדד 0.

127
00:08:34,450 --> 00:08:41,799
אם המערך הוא באורך 4, כמו בדוגמא הזו, אז האלמנט האחרון שלך יהיה בשעה 3 מדד

128
00:08:41,799 --> 00:08:44,810
אשר הם 4 - 1.

129
00:08:45,940 --> 00:08:48,420
אז כדי ליצור את המערך, היית עושה משהו כזה.

130
00:08:48,420 --> 00:08:51,440
אמר שאתה רוצה מערך כפול.

131
00:08:51,440 --> 00:08:56,520
זה שהולך לכל סוג של סוג נתונים,.

132
00:08:56,520 --> 00:09:00,210
אז תגיד שאתה רוצה מערך כפול. אומר שאתה רוצה לקרוא לזה תיבת דואר.

133
00:09:00,210 --> 00:09:04,760
בדיוק כמו שהיית לאתחל כל פעמים אחרות,

134
00:09:04,760 --> 00:09:09,760
היית אומר כפול ולאחר מכן את השם, אבל הפעם אנו שמים את הסוגריים המרובעים,

135
00:09:09,760 --> 00:09:13,570
ואז המספר יהיה האורך של המערך.

136
00:09:13,570 --> 00:09:16,840
שים לב כי במערכים לא תוכל אי פעם לשנות את האורך,

137
00:09:16,840 --> 00:09:21,230
כך שתמיד יש להגדיר ולבחור כמה תיבות,

138
00:09:21,230 --> 00:09:25,440
כמה ערכי המערך שלך הולך להחזיק.

139
00:09:25,440 --> 00:09:31,820
אז כדי להגדיר ערכים שונים במערך שלך, אתה הולך להשתמש בתחביר הבא זה,

140
00:09:31,820 --> 00:09:33,200
כפי שאתם רואים בשקופית.

141
00:09:33,200 --> 00:09:37,620
יש לך 0 תיבת דואר המדד ייקבעו ל -1.2,

142
00:09:37,620 --> 00:09:42,180
סט תיבת דואר ראשי 1-2.4, וכו '

143
00:09:42,180 --> 00:09:47,910
אז עכשיו שסקרנו מערכים קצת, בואו נחזור לargc וargv.

144
00:09:47,910 --> 00:09:52,220
אנו יודעים כי argv הוא עכשיו מערך של מחרוזות.

145
00:09:52,220 --> 00:09:55,080
לכן, כאשר משתמש עובר ב-- אומרים שהם פועלים בתכנית -

146
00:09:55,080 --> 00:09:58,740
הם אומרים. / שלום דוד מלאן,

147
00:09:58,740 --> 00:10:05,160
מה התכנית תעשה בשבילך כבר לבוא דווקא עם מה argc וargv הם.

148
00:10:05,160 --> 00:10:07,620
אז אתה לא צריך לדאוג בקשר לזה.

149
00:10:07,620 --> 00:10:14,370
Argc במקרה זה יהיה 3, כי הוא רואה 3 מילים שונות מופרדות על ידי רווחים.

150
00:10:14,370 --> 00:10:18,850
ואם כך את המערך במקרה זה, במדד הראשון יהיה. / שלום,

151
00:10:18,850 --> 00:10:21,770
את הבא אחריו הדוד, מלאן הבא.

152
00:10:21,770 --> 00:10:25,640
האם מישהו רואה מייד מה קשר בין argv,

153
00:10:25,640 --> 00:10:28,990
 המערך, וargc הוא?

154
00:10:32,820 --> 00:10:38,090
כן. אנחנו נגיע לזה בדוגמה בargs.c.

155
00:10:38,090 --> 00:10:42,880
בואו נראה אם ​​אנחנו יכולים לנצל את היחסים בין 2.

156
00:10:42,880 --> 00:10:46,550
כאן אתה עשוי לגלות כי במכשיר יישום ברירת המחדל

157
00:10:46,550 --> 00:10:49,450
כדי לפתוח קבצים. C הוא לעתים Emacs.

158
00:10:49,450 --> 00:10:54,660
אבל אנחנו רוצים להתמודד עם gedit, אז מה אתה יכול לעשות הוא שאתה ממש יכול ללחוץ על קובץ C שלך,

159
00:10:54,660 --> 00:11:04,580
ללכת נכסים, פתח עם, ולאחר מכן בחר gedit, קבע כברירת מחדל,

160
00:11:04,580 --> 00:11:13,020
ועכשיו התכנית שלך צריכה לפתוח בgedit במקום Emacs.

161
00:11:14,710 --> 00:11:16,290
מושלם.

162
00:11:17,120 --> 00:11:25,520
אז הנה יש לי תכנית שאני רוצה להדפיס את כל ארגומנט שורת פקודה.

163
00:11:25,520 --> 00:11:32,050
אז מה תשומות המשתמש, אני רוצה בעצם להחזיר אותו חזרה אליהם בשורה חדשה.

164
00:11:32,050 --> 00:11:36,710
אז מה מבנה שאנחנו יכולים להשתמש בו כדי לחזר על משהו -

165
00:11:36,710 --> 00:11:40,380
משהו שאתה כנראה השתמשת ב1 pset?

166
00:11:40,380 --> 00:11:45,840
אם אתה רוצה לעבור את מספר מוגדר של דברים? >> [תלמיד] ללולאה.

167
00:11:45,840 --> 00:11:48,910
ללולאה. בדיוק. אז בואו נתחיל עם ללולאה.

168
00:11:48,910 --> 00:11:56,900
יש לנו עבור אני int = 0. בואו נתחיל עם משתנה אתחול רגיל.

169
00:11:56,900 --> 00:12:02,370
אני הולך לעזוב את התנאי לסט ואז אומר אני + +, הולך לעשות דברים שם.

170
00:12:02,370 --> 00:12:04,090
בסדר.

171
00:12:04,090 --> 00:12:11,590
אז חשבתי לחזור לargv, אם argv הוא רשימת הארגומנטים שמועברים לתכנית

172
00:12:11,590 --> 00:12:15,380
וargc הוא מספר הארגומנטים בתכנית,

173
00:12:15,380 --> 00:12:21,280
אז זה אומר שargc הוא למעשה אורך argv, ימינה,

174
00:12:21,280 --> 00:12:28,970
משום שיש הולך להיות ויכוחים רבים ככל הערך של argc.

175
00:12:28,970 --> 00:12:35,910
אז אם אנחנו רוצים לחזר על כל אלמנט בargv,

176
00:12:35,910 --> 00:12:43,290
אנחנו הולכים בכל פעם שירצו לגשת למשתנה בargv במדד המסוים.

177
00:12:43,290 --> 00:12:49,060
זה יכול להיות מיוצג עם זה, נכון?

178
00:12:49,060 --> 00:12:53,430
משתנה זה כאן מייצג את המחרוזת המסוימת במקרה זה

179
00:12:53,430 --> 00:12:57,030
כי זה מערך מחרוזת - מחרוזת מסוימת במדד זה נתון.

180
00:12:57,030 --> 00:13:00,690
מה שאנחנו רוצים לעשות, במקרה זה אנו רוצים להדפיס אותו, אז בואו נגיד printf.

181
00:13:00,690 --> 00:13:04,680
ועכשיו argv הוא מחרוזת, ולכן אנחנו רוצים לשים מציינים מקום שיש.

182
00:13:04,680 --> 00:13:08,430
אנחנו רוצים בשורה חדשה, רק כדי לגרום לו להיראות טוב.

183
00:13:08,430 --> 00:13:12,530
אז הנה יש לנו לולאה. אין לנו מצב עדיין.

184
00:13:12,530 --> 00:13:20,020
אז אני מתחיל ב0, ולאחר מכן בכל פעם שזה הולך להדפיס את מחרוזת הנתונה

185
00:13:20,020 --> 00:13:22,980
באותו מדד מסוים במערך.

186
00:13:22,980 --> 00:13:28,410
לכן, כאשר אנו רוצים להפסיק את ההדפסה של אלמנטים במערך?

187
00:13:28,410 --> 00:13:35,720
כשסיימנו, נכון? כשהגענו לסוף המערך.

188
00:13:35,720 --> 00:13:38,870
אז אנחנו לא רוצים לחרוג עבר האורך של המערך,

189
00:13:38,870 --> 00:13:43,700
ואנחנו כבר יודעים שאנחנו לא צריכים ממש פעילים לברר מה האורך של argv הוא

190
00:13:43,700 --> 00:13:47,520
כי זה שניתן לנו, ומה זה? Argc. בדיוק.

191
00:13:47,520 --> 00:13:56,640
אז אנחנו רוצים לעשות מספר argc זה תהליך של פעמים.

192
00:13:56,640 --> 00:13:59,550
אני לא במדריך הנכון.

193
00:14:02,100 --> 00:14:03,490
בסדר.

194
00:14:03,490 --> 00:14:08,990
עכשיו בואו נעשה ארגומנטים. אין טעויות, וזה נהדר.

195
00:14:08,990 --> 00:14:11,430
אז בואו פשוט להריץ ארגומנטים.

196
00:14:11,430 --> 00:14:15,130
מה זה אמור לחזור אלינו? זה רק הולך להדפיס אותו בחזרה.

197
00:14:15,130 --> 00:14:18,320
"אתה הוזנת ארגומנטים לתכנית; אני הולך להחזיר לך אותו."

198
00:14:18,320 --> 00:14:23,170
אז אניח שאנחנו רוצים לומר ארגומנטים אז בר foo.

199
00:14:23,170 --> 00:14:26,570
ואז זה מדפיס אותו בחזרה אלינו. בסדר?

200
00:14:26,570 --> 00:14:30,790
אז הנה דוגמה של איך אתה יכול להשתמש argc וargv

201
00:14:30,790 --> 00:14:33,460
ידיעת argc שמייצגת את האורך של argv.

202
00:14:33,460 --> 00:14:42,750
ודא שאתה עושה לא פעם עם גישה למערכים אחד מעבר לאורכו של המערך

203
00:14:42,750 --> 00:14:45,140
משום C בהחלט צועק עליך.

204
00:14:45,140 --> 00:14:47,560
אתה תקבל משהו שנקרא אשמת פילוח,

205
00:14:47,560 --> 00:14:52,470
שהוא אף פעם לא כיף, בעצם אומר שאתה מנסה לגשת למשהו

206
00:14:52,470 --> 00:14:55,000
שאינו קיים, לא שייך לך.

207
00:14:55,000 --> 00:14:59,430
אז לייתר ביטחון, ובמיוחד עם אפס האינדקס, אנו לא רוצים -

208
00:14:59,430 --> 00:15:02,390
כמו למשל, אם יש לנו מערך באורך 4,

209
00:15:02,390 --> 00:15:07,240
שהאינדקס של המערך 4 אינו קיים מפני שמתחילים ב 0, באפס מדד.

210
00:15:07,240 --> 00:15:11,730
זה יהפוך לטבע שנייה בדיוק כמו ללולאות כאשר אנו מתחילים ב 0.

211
00:15:11,730 --> 00:15:13,610
אז רק לזכור את זה.

212
00:15:13,610 --> 00:15:22,590
אתה לא רוצה אי פעם לגשת לאינדקס של מערך זה מעבר להישג שלך.

213
00:15:26,710 --> 00:15:32,560
כך אנו יכולים לראות עכשיו איך שאנחנו יכולים סוג של גישה

214
00:15:32,560 --> 00:15:35,930
טיעוני שורת הפקודה, כי הם עברו פנימה

215
00:15:35,930 --> 00:15:41,330
אבל כמו שאתה רואה את המחרוזת, argv הוא למעשה מערך מחרוזת.

216
00:15:41,330 --> 00:15:45,740
אז זה ממש לא שלם עדיין, אבל בקיסר אנחנו רוצים להתמודד עם מספרים שלמים.

217
00:15:45,740 --> 00:15:54,430
למזלנו, יש פונקציה שיצרה עבורנו, כי בעצם יכול להמיר מחרוזת למספר שלם.

218
00:15:54,430 --> 00:15:58,710
גם כאן אין לנו עניין עם קלט משתמש שבו אנו מעודדים אותם

219
00:15:58,710 --> 00:16:03,740
עבור קלט כאן לקבלת המפתח, ולכן אנחנו לא יכולים reprompt ואומרים,

220
00:16:03,740 --> 00:16:07,840
"הו, תן לי מספר שלם אחר, אומר, אם זה לא חוקי."

221
00:16:07,840 --> 00:16:10,540
אבל אנחנו עדיין צריכים לבדוק לשימוש נכון.

222
00:16:10,540 --> 00:16:13,520
בקיסר הם מורשים רק לעבור במספר 1,

223
00:16:13,520 --> 00:16:18,030
ולכן הם צריכים לרוץ. / קיסר, ואז הם צריכים לתת לך מספר.

224
00:16:18,030 --> 00:16:23,660
אז argc חייב להיות מספר מסוים.

225
00:16:23,660 --> 00:16:29,060
מה מספר שהייתי להיות אם הם צריכים לעבור אותך. / קיסר ולאחר מכן מפתח?

226
00:16:29,060 --> 00:16:32,920
מה הוא argc? >> [תלמיד] 2. >> שתיים. בדיוק.

227
00:16:32,920 --> 00:16:35,490
אז אתה רוצה לוודא שargc הוא 2.

228
00:16:35,490 --> 00:16:39,620
אחרת אתה בעצם מסרב להפעיל את התכנית.

229
00:16:39,620 --> 00:16:43,040
בעיקרי זה פונקציה שאומרת int ראשי,

230
00:16:43,040 --> 00:16:47,360
אם כך אנחנו תמיד ב0 תמורת תרגול טובים בסוף התכנית מוצלחת.

231
00:16:47,360 --> 00:16:50,840
אז אם, יניח, הם נותנים לך 3 טיעוני שורת פקודה במקום 2

232
00:16:50,840 --> 00:16:54,350
או לתת לך 1, למשל, אז מה שאתה תעשה זה שאתה רוצה לבדוק ש

233
00:16:54,350 --> 00:16:59,900
ואז לחזור 1 אומר, לא, אני לא יכול להמשיך בתכנית זו.

234
00:16:59,900 --> 00:17:03,190
[תלמיד] אין ולא יכול להיות מקום בטקסט שלך. >> סליחה?

235
00:17:03,190 --> 00:17:06,780
[תלמיד] לא יכול להיות מקום בטקסט שאתה מנסה להצפין.

236
00:17:06,780 --> 00:17:08,480
אה!

237
00:17:08,480 --> 00:17:11,280
במונחים של הטקסט שאנחנו מנסים להצפין, שמקורו דווקא בהמשך

238
00:17:11,280 --> 00:17:13,970
כאשר אנו נותנים טקסט.

239
00:17:13,970 --> 00:17:18,260
אז כרגע אנחנו פשוט מקבלים את הטענות כפקודת מספר בפועל,

240
00:17:18,260 --> 00:17:21,579
השינוי בפועל עבור הצפנת הקיסר.

241
00:17:21,579 --> 00:17:27,569
[תלמיד] למה אתה צריך 2 לעומת רק argc 1? יש בהחלט מספר 1.

242
00:17:27,569 --> 00:17:32,200
נכון. הסיבה שאנחנו צריכים 2 לargc במקום 1

243
00:17:32,200 --> 00:17:36,260
משום שכאשר אתה מפעיל תכנית ואומר. / או קיסר. / שלום,

244
00:17:36,260 --> 00:17:38,280
שלמעשה נחשב ארגומנט שורת פקודה.

245
00:17:38,280 --> 00:17:43,020
אז שכבר לוקח עד 1 וכן אז אנחנו מזינים נוספים 1.

246
00:17:45,030 --> 00:17:49,440
אז אתה בעצם מזין מחרוזת בארגומנט שורת הפקודה.

247
00:17:49,440 --> 00:17:52,730
מה אתה רוצה לעשות, לקיסר אנחנו רוצים להתמודד עם מספר שלם,

248
00:17:52,730 --> 00:17:57,180
כך שאתה יכול להשתמש בפונקצית atoi זה.

249
00:17:57,180 --> 00:18:02,850
ובעצם, אתה תעבור אותו בחוט ואז זה יחזיר אותך חזרה שלם

250
00:18:02,850 --> 00:18:06,070
אם זה אפשרי לעשות את זה במחרוזת של מספרים שלמים.

251
00:18:06,070 --> 00:18:10,960
עכשיו זוכר מתי שאנחנו מתעסקים עם דברי printf או GetString, כמו ש,

252
00:18:10,960 --> 00:18:13,390
אנו כוללים את הספריות ספציפיות לנו.

253
00:18:13,390 --> 00:18:19,450
אז בהתחלה אנחנו מתחילים עם תג קלט / פלט סטנדרטי,. שעות, משהו כמו שחשיש.

254
00:18:19,450 --> 00:18:22,430
ובכן, atoi אינו באחת מהספריות הללו,

255
00:18:22,430 --> 00:18:26,600
אז מה יש לנו לעשות הוא שיש לנו לכלול את הספרייה המתאימה לכך.

256
00:18:26,600 --> 00:18:32,720
אז זוכר חזרה לWalkthrough 1 שבו אני דנתי את הפונקציה הידנית.

257
00:18:32,720 --> 00:18:37,110
אתה מקליד אדם במסוף שלך ולאחר מכן ואחריו השם של פונקציה.

258
00:18:37,110 --> 00:18:39,720
וכדי שיביא את רשימה שלמה של השימוש בו,

259
00:18:39,720 --> 00:18:42,890
אבל גם זה יביא אותה הספרייה ששייכת.

260
00:18:42,890 --> 00:18:47,000
אז אני אשאיר לך את זה כדי להשתמש בפונקציה הידנית עם atoi

261
00:18:47,000 --> 00:18:53,360
ולהבין איזה ספרייה אתה צריך לכלול כדי שתוכל להשתמש בפונקצית atoi.

262
00:18:54,450 --> 00:18:57,670
אז יש לנו את המפתח ועכשיו זה מגיע מקבל טקסט הרגיל,

263
00:18:57,670 --> 00:19:01,820
וכך למעשה הוא הולך להיות קלט משתמש שבו אתה תבקש.

264
00:19:01,820 --> 00:19:05,540
התמודדנו עם GetInt וGetFloat, וכך באותה הרוח

265
00:19:05,540 --> 00:19:07,670
אנחנו הולכים להיות התמודדות עם GetString.

266
00:19:07,670 --> 00:19:12,440
אבל במקרה זה אנחנו לא צריכים לעשות כל לעשות בזמן או בזמן לולאות כדי לבדוק.

267
00:19:12,440 --> 00:19:14,480
GetString בהחלט נותן לנו מחרוזת,

268
00:19:14,480 --> 00:19:17,630
ואנחנו הולכים כדי להצפין את כל מה שהמשתמש נותן לנו.

269
00:19:17,630 --> 00:19:23,770
אז אתה יכול להניח שכל מחרוזות שהוזנו משתמש אלה הם נכונים.

270
00:19:23,770 --> 00:19:24,670
גדול.

271
00:19:24,670 --> 00:19:27,270
אז ברגע שיש לך את המפתח וברגע שיש לך את הטקסט,

272
00:19:27,270 --> 00:19:31,660
עכשיו מה שנשאר זה שיש לך בצופן בטקסט.

273
00:19:31,660 --> 00:19:36,530
רק כדי לכסות במהירות על שפה, הטקסט הוא מה שהמשתמש נותן לך,

274
00:19:36,530 --> 00:19:41,030
והמוצפן הוא מה שאתה חוזר אליהם.

275
00:19:42,450 --> 00:19:45,850
אז מייתרים, כדי להיות מסוגל לעבור למעשה אות אחרת אות

276
00:19:45,850 --> 00:19:48,550
כי יש לנו להעביר את כל מכתב,

277
00:19:48,550 --> 00:19:51,390
אנו מבינים שלהתחייבות, אם אנחנו סוג של לקלף את השכבה,

278
00:19:51,390 --> 00:19:54,130
אנו רואים שהם פשוט באמת רשימה של תווים.

279
00:19:54,130 --> 00:19:55,930
אחד מגיע בזה אחר זה.

280
00:19:55,930 --> 00:20:01,690
וכך אנו יכולים לטפל במחרוזות כמערכים כי הם מערכים של תווים.

281
00:20:01,690 --> 00:20:05,640
אז אומר שיש לך מחרוזת בשם טקסט,

282
00:20:05,640 --> 00:20:09,400
ובתוך טקסט שמשתנה מאוחסן זו CS50.

283
00:20:09,400 --> 00:20:15,680
אז טקסט במדד 0 יהיה הבירה T, 1 המדד יהיה שעות, וכו '

284
00:20:17,530 --> 00:20:23,970
ולאחר מכן עם מערכים, בדוגמא argc בargs.c,

285
00:20:23,970 --> 00:20:27,090
ראינו שיש לנו כדי לעבור על מערך

286
00:20:27,090 --> 00:20:32,440
ואז היינו צריכים לחזר מi = 0 עד i היא פחות מהאורך.

287
00:20:32,440 --> 00:20:35,560
אז אנחנו זקוקים לדרך להבין מה האורך של המחרוזת שלנו הוא

288
00:20:35,560 --> 00:20:37,090
אם אנחנו הולכים לחזר על זה.

289
00:20:37,090 --> 00:20:42,300
למזלנו שוב, יש פונקציה שיש לנו, אם כי בשלב מאוחר יותר בCS50

290
00:20:42,300 --> 00:20:45,860
אתה בהחלט תוכל ליישם ולבצע פונקציה משלך

291
00:20:45,860 --> 00:20:48,260
שיכול לחשב את אורכו של חוט.

292
00:20:48,260 --> 00:20:52,120
אבל נכון לעכשיו אנחנו הולכים להשתמש באורך מחרוזת, כך strlen.

293
00:20:52,120 --> 00:21:00,440
אתה עובר בחוט, ואז הוא יחזיר לך int שמייצג את האורך של המחרוזת שלך.

294
00:21:00,440 --> 00:21:05,840
בואו נסתכל על דוגמה של איך אנחנו יכולים להיות מסוגלים לחזר על כל תו במחרוזת

295
00:21:05,840 --> 00:21:08,470
ולעשות עם זה משהו.

296
00:21:08,470 --> 00:21:13,250
מה שאנחנו רוצים לעשות הוא לחזר על כל תו של המחרוזת,

297
00:21:13,250 --> 00:21:19,150
ומה שאנחנו רוצים לעשות הוא להדפיסנו חזרה כל תו 1 עד 1

298
00:21:19,150 --> 00:21:22,060
מלבד נוסיף משהו לצד זה.

299
00:21:22,060 --> 00:21:27,020
אז בואו נתחיל עם ללולאה. אני int = 0.

300
00:21:27,020 --> 00:21:30,070
אנחנו הולכים להשאיר מקום למצבו.

301
00:21:32,700 --> 00:21:36,840
אנחנו רוצים לחזר עד שאנחנו מגיעים לסוף המחרוזת, נכון?

302
00:21:36,840 --> 00:21:41,340
אז מה פונקציה נותן לנו את אורכו של החוט?

303
00:21:41,340 --> 00:21:43,160
[תגובת תלמיד לא נשמעה]

304
00:21:43,160 --> 00:21:46,420
זה האורך של הארגומנטים בשורת הפקודה.

305
00:21:46,420 --> 00:21:50,650
אבל עבור מחרוזת שאנחנו רוצים להשתמש בפונקציה שנותנת לנו את אורכו של החוט.

306
00:21:50,650 --> 00:21:53,090
אז זה אורך מחרוזת.

307
00:21:53,090 --> 00:21:57,130
וכן אז אתה צריך לעבור במחרוזת לזה.

308
00:21:57,130 --> 00:21:59,760
הוא צריך לדעת מה מחרוזת שהוא צריך לחשב את האורך.

309
00:21:59,760 --> 00:22:03,160
אז במקרה הזה יש לנו עסק עם מחרוזת s.

310
00:22:04,790 --> 00:22:05,860
גדול.

311
00:22:05,860 --> 00:22:10,770
אז מה אנחנו רוצים לעשות, בואו printf.

312
00:22:10,770 --> 00:22:14,850
עכשיו, אנחנו רוצים להתמודד עם תווים. אנו רוצים להדפיס כל תו בודד.

313
00:22:14,850 --> 00:22:22,150
כאשר אתה רוצה את זה כדי להדפיס את מצוף, שהיית משתמש במציין מיקום כמו% f.

314
00:22:22,150 --> 00:22:24,580
עם int היית משתמש ד%.

315
00:22:24,580 --> 00:22:30,890
וכך באופן דומה, עם אופי אתה משתמש ג% להגיד שאני הולך להיות דפוס אופי

316
00:22:30,890 --> 00:22:34,570
שמאוחסן בתוך משתנה.

317
00:22:34,570 --> 00:22:40,840
אז יש לנו את זה, ובואו נוסיף תקופה ומקום אליו.

318
00:22:40,840 --> 00:22:45,430
איזו דמות שאנחנו משתמשים?

319
00:22:45,430 --> 00:22:49,780
אנחנו הולכים להיות באמצעות מה שדמות שאנחנו במחרוזת.

320
00:22:49,780 --> 00:22:52,890
אז אנחנו הולכים להיות באמצעות משהו עם מחרוזת,

321
00:22:52,890 --> 00:22:56,420
אבל אנחנו רוצים להיות בגישה לאופי מסוים שם.

322
00:22:56,420 --> 00:23:02,740
אז אם מחרוזת היא פשוט מערך, אז איך אנחנו לגשת אלמנטים של מערכים?

323
00:23:02,740 --> 00:23:06,480
יש לנו אותן סוגריים מרובעים, ולאחר מכן אנחנו מכניסים את המדד לשם.

324
00:23:06,480 --> 00:23:11,820
אז יש לנו סוגריים מרובעים. האינדקס שלנו במקרה זה אנחנו יכולים פשוט להשתמש. בדיוק.

325
00:23:15,290 --> 00:23:22,370
אז הנה מה שאנחנו אומרים שאנחנו הולכים להיות דפוס אופי אחריו נקודה וחלל,

326
00:23:22,370 --> 00:23:30,870
והדמות שהולכת להיות מכתב ith במחרוזת שלנו.

327
00:23:32,920 --> 00:23:39,330
אני רק הולך להציל את זה. אוקיי.

328
00:23:42,510 --> 00:23:46,840
עכשיו אני הולך להפעיל את אורך מחרוזת.

329
00:23:46,840 --> 00:23:53,440
אז היה לנו מחרוזת בשם OMG, ועכשיו זה הדגיש עוד יותר.

330
00:23:53,440 --> 00:23:57,870
כמו כן, אניח שאנו באמת רוצים לקבל מחרוזת מהמשתמש.

331
00:23:57,870 --> 00:23:59,580
איך ניתן לעשות זאת?

332
00:23:59,580 --> 00:24:01,610
לפני כן, איך הגענו int?

333
00:24:01,610 --> 00:24:08,040
אנחנו אמרנו GetInt, נכון? אבל זה לא int, אז בואו GetString.

334
00:24:11,780 --> 00:24:17,770
בואו נעשה את אורך מחרוזת. כאן אנו לא נכנסנו הנחיה ספציפית.

335
00:24:17,770 --> 00:24:19,940
אז אני לא יודע.

336
00:24:19,940 --> 00:24:23,820
אני הולך לשים את השם שלי בפה וכן אז אני יכול לעשות אחד מהדברים האלה

337
00:24:23,820 --> 00:24:29,600
איפה אני להקצות מילה לכל אות או משהו כזה. מגניב.

338
00:24:29,600 --> 00:24:31,900
אז זה אורך מחרוזת.

339
00:24:33,000 --> 00:24:34,640
אז חזר לקיסר.

340
00:24:34,640 --> 00:24:38,620
יש לנו כמה כלים באופן שנעמיק את המחרוזת,

341
00:24:38,620 --> 00:24:41,250
איך לגשת לכל רכיב בנפרד.

342
00:24:41,250 --> 00:24:44,720
אז עכשיו אנחנו יכולים לחזור לתכנית.

343
00:24:44,720 --> 00:24:48,650
כפי שציינתי קודם, בטבלת ASCII, החבר הכי הטוב שלך,

344
00:24:48,650 --> 00:24:52,300
אתה הולך לראות את המספרים הקשורים לכל מכתב.

345
00:24:52,300 --> 00:24:55,900
אז הנה אומרים הטקסט שלנו הוא יש לי סחרחורת!

346
00:24:55,900 --> 00:25:01,090
אז כל אחד מהתווים האלה הולך להיות מספר וערך ASCII הקשור אליו,

347
00:25:01,090 --> 00:25:04,710
אפילו גרש, גם המרחב, גם בסימן הקריאה,

348
00:25:04,710 --> 00:25:06,600
אז אתה רוצה לשמור את זה בחשבון.

349
00:25:06,600 --> 00:25:12,360
אז אומר שהמפתח שלנו למשתמש הכלול בארגומנט שורת הפקודה שלהם הוא 6.

350
00:25:12,360 --> 00:25:17,770
כלומר, למכתב הראשון, שהוא אני, שמיוצג על ידי 73,

351
00:25:17,770 --> 00:25:25,610
אתה רוצה להחזיר להם כל מה שמכתב מיוצג על ידי ערך ASCII של 73 + 6.

352
00:25:25,610 --> 00:25:29,020
במקרה זה שיהיה 79.

353
00:25:30,840 --> 00:25:35,040
עכשיו אנחנו רוצים ללכת לתו הבא.

354
00:25:35,040 --> 00:25:40,960
אז הבא במדד של 1 הטקסט יהיה הגרש.

355
00:25:40,960 --> 00:25:46,780
אבל תזכור אנחנו רק רוצים להצפין את האותיות.

356
00:25:46,780 --> 00:25:50,040
אז אנחנו רוצים לוודא שהגרש בעצם נשאר אותו הדבר,

357
00:25:50,040 --> 00:25:54,310
שלא נשנה מ 39 ל 45 מה הוא.

358
00:25:54,310 --> 00:25:57,150
אנחנו רוצים לשמור אותו כגרש.

359
00:25:57,150 --> 00:26:00,780
אז אנחנו רוצים לזכור בצופן האותיות בלבד

360
00:26:00,780 --> 00:26:04,560
כי אנחנו רוצים את כל סמלים האחרים כדי להישאר ללא שינוי בתכנית שלנו.

361
00:26:04,560 --> 00:26:07,130
דבר נוסף שאנחנו רוצים הוא לשמר היוון.

362
00:26:07,130 --> 00:26:10,250
לכן, כאשר יש לך אות גדולה, זה צריך להישאר כאותיות רישיות.

363
00:26:10,250 --> 00:26:12,830
אותיות קטנות צריכות להישאר כאותיות קטנות.

364
00:26:13,620 --> 00:26:19,480
אז כמה פונקציות שימושיות כדי להיות מסוגלות להתמודד עם מכתבי enciphering בלבד

365
00:26:19,480 --> 00:26:22,380
ולשמור שמירת הייוון של דברים

366
00:26:22,380 --> 00:26:25,130
היא את isalpha, isupper, פונקציות islower.

367
00:26:25,130 --> 00:26:29,270
ולכן אלה הם פונקציות שמחזירות לך ערך בוליאני.

368
00:26:29,270 --> 00:26:34,180
בעיקרון, אמת או שקר. האם זה אותיות גדולות? האם זה אלפאנומרי?

369
00:26:34,180 --> 00:26:37,180
האם זה מכתב, למעשה.

370
00:26:37,180 --> 00:26:41,070
אז הנה 3 דוגמאות של איך היית להשתמש בפונקציה ש.

371
00:26:41,070 --> 00:26:47,060
בעיקרון, אתה יכול לבדוק אם הערך שהוחזר לך על ידי שהפונקציה הוא אמת או שקר

372
00:26:47,060 --> 00:26:49,400
המבוסס על קלט.

373
00:26:49,400 --> 00:26:54,880
או שיעשה משהו לא להצפין או צופנים או לוודא שזה באותיות גדולה, ועוד

374
00:26:54,880 --> 00:27:01,080
[תלמיד] אתה יכול פשוט להסביר אלו קצת יותר ואיך אתה משתמש בם? >> כן, בטח.

375
00:27:01,080 --> 00:27:08,470
אז אם אנחנו מסתכלים אחורה, כאן יש לנו הוני, נכון?

376
00:27:08,470 --> 00:27:14,550
אז אנחנו יודעים שאני הולך לO כי אני + 6 הוא O.

377
00:27:14,550 --> 00:27:18,740
אבל אנחנו רוצים לוודא שO הולך להיות בירת O.

378
00:27:18,740 --> 00:27:22,940
אז בעצם, שהוא סוג של הולך לשנות הקלט שלנו.

379
00:27:22,940 --> 00:27:26,870
אז אם זה אותיות גדול או לא תהיה סוג של שינוי האופן שבו אנו מתמודדים עם זה.

380
00:27:26,870 --> 00:27:32,360
אז אם אנחנו משתמשים בפונקצית isupper שבמדד מסוים,

381
00:27:32,360 --> 00:27:36,480
כך isupper ("אני"), שמחזיר לנו אמיתי, ולכן אנחנו יודעים שזה עליון.

382
00:27:36,480 --> 00:27:40,360
על סמך זה אז, אחר כך תלכו לנוסחה

383
00:27:40,360 --> 00:27:42,750
כי אתה תהיה באמצעות להעביר דברים בקיסר,

384
00:27:42,750 --> 00:27:46,560
אז בעצם, יש הולך להיות נוסחה מעט שונה אם זה אותיות גדול

385
00:27:46,560 --> 00:27:50,670
בניגוד לאותיות קטנות. הגיוני?

386
00:27:51,020 --> 00:27:52,760
כן. אין בעיה.

387
00:27:54,900 --> 00:27:58,990
דברתי קצת על הוספת 6 למכתב, שלא ממש הגיוני

388
00:27:58,990 --> 00:28:05,500
למעט כאשר אנחנו סוג של ההבנה שהדמויות הללו

389
00:28:05,500 --> 00:28:08,920
הם סוג של החלפה עם מספרים שלמים.

390
00:28:08,920 --> 00:28:11,250
מה שאנו עושים זה סוג של יציקה משתמעת שימוש.

391
00:28:11,250 --> 00:28:18,100
אנחנו נלך לליהוק קצת יותר מאוחר שבו אתה לוקח ערך והופך אותם לסוג אחר

392
00:28:18,100 --> 00:28:20,440
ממה שהיה במקור.

393
00:28:20,440 --> 00:28:25,910
אבל עם זה אנו pset נוכל להשתמש בסוג של דמויות לסירוגין

394
00:28:25,910 --> 00:28:30,880
והערכים השלמים המקבילים להם.

395
00:28:30,880 --> 00:28:35,140
אז אם אתה פשוט לעטוף את דמות רק עם מרכאות בודדות,

396
00:28:35,140 --> 00:28:40,390
אז אתה תהיה מסוגל לעבוד עם אותו עם מספרים שלמים, התמודדות עימו כמספר שלם.

397
00:28:40,390 --> 00:28:48,040
אז ההון C מתייחס ל 67. ו אותיות קטנות מתייחס ל102.

398
00:28:48,040 --> 00:28:51,480
שוב, אם אתה רוצה לדעת את הערכים הללו, יסתכלו על טבלת ASCII שלך.

399
00:28:51,480 --> 00:28:56,160
אז בואו נלך לכמה דוגמאות של איך ייתכן שתוכל להפחית ולהוסיף,

400
00:28:56,160 --> 00:29:03,130
איך אתה יכול ממש ממש לעבוד עם הדמויות הללו, להשתמש בם לסירוגין.

401
00:29:03,870 --> 00:29:11,350
אני אומר ASCIIMath כי הוא הולך לחשב את התוספת של דמות למספר שלם

402
00:29:11,350 --> 00:29:17,590
ולאחר מכן מציג את אופי התוצאה, כמו גם את ערך ASCII שנוצר.

403
00:29:17,590 --> 00:29:22,290
אז הנה אני אומר - להכין מעסקה עם החלק הזה בהמשך -

404
00:29:22,290 --> 00:29:29,100
אבל בעצם, אני אומר שהמשתמש צריך לומר ASCIIMath לרוץ יחד עם מפתח,

405
00:29:29,100 --> 00:29:30,880
ואני אומר שמפתח שהוא הולך להיות המספר

406
00:29:30,880 --> 00:29:34,600
שבה אנו הולכים להוסיף הדמות הזאת.

407
00:29:34,600 --> 00:29:38,560
אז הנה שם לב שמאז אני דורש מפתח,

408
00:29:38,560 --> 00:29:40,590
מאז שאני דורש מהם שאתה נותן לי דבר 1,

409
00:29:40,590 --> 00:29:45,600
אני רוצה רק לקבל. / Asciimath ומפתח.

410
00:29:45,600 --> 00:29:49,330
אז אני הולך לדרוש שargc שווה ל 2.

411
00:29:49,330 --> 00:29:54,360
אם זה לא, אז אני הולך להחזיר 1 והתכנית תסתיים.

412
00:29:55,070 --> 00:29:58,540
אז אני אומר המפתח הוא לא הולך להיות ויכוח שורת הפקודה הראשונה,

413
00:29:58,540 --> 00:30:05,080
זה הולך להיות שני אחת, וכמו שאתה רואה כאן,

414
00:30:05,080 --> 00:30:11,790
אני הולך להפוך את זה למספר שלם.

415
00:30:15,740 --> 00:30:19,230
ואז אני הולך להגדרת אופי להיות r.

416
00:30:19,230 --> 00:30:23,970
שים לב כי הסוג של chr משתנה הוא למעשה מספר שלם.

417
00:30:23,970 --> 00:30:30,480
הדרך שאני מסוגל להשתמש r כשלם היא על ידי encasing זה עם המרכאות בודדות האלה.

418
00:30:33,850 --> 00:30:40,560
אז בחזרה להצהרת printf שבו יש לנו מקום עבור תו

419
00:30:40,560 --> 00:30:43,590
ולאחר מכן מציין מיקום עבור מספר שלם,

420
00:30:43,590 --> 00:30:49,450
האופי מיוצג על ידי chr, והשלם הוא המפתח.

421
00:30:49,450 --> 00:30:54,320
וכך אז אנחנו הולכים בתוצאה להוסיף 2 ביחד.

422
00:30:54,320 --> 00:30:58,420
אז אנחנו הולכים להוסיף R + מה המפתח הוא,

423
00:30:58,420 --> 00:31:03,520
ואז אנחנו הולכים להדפיס את התוצאה של זה.

424
00:31:06,210 --> 00:31:14,220
אז בואו נעשה asciimath. זה מעודכן, אז בוא פשוט להפעיל asciimath.

425
00:31:14,220 --> 00:31:18,290
אה, אבל תראה, זה לא לעשות שום דבר, כי אנחנו לא ממש נותנים לו מפתח.

426
00:31:18,290 --> 00:31:23,850
אז כשזה פשוט חזר 1, הפונקציה העיקרית שלנו, זה פשוט חזר אלינו.

427
00:31:23,850 --> 00:31:29,250
אז בואו נעבור במפתח. מישהו נתן לי מספר. >> [תלמיד] 4.

428
00:31:29,250 --> 00:31:30,920
4. אוקיי.

429
00:31:30,920 --> 00:31:39,280
אז r גדל ב 4 הוא הולך לתת לנו V, אשר תואם את ערך ASCII של 118.

430
00:31:39,280 --> 00:31:43,880
ואז זה סוג של הגיוני כי -

431
00:31:43,880 --> 00:31:51,250
למעשה, אני יכול לשאול אותך, מה אתה חושב שערך ASCII של r הוא אם r + 4 הוא 118?

432
00:31:53,070 --> 00:31:55,470
אז כן, r הוא 114.

433
00:31:55,470 --> 00:32:03,010
אז אם אתה מסתכל על שולחן ASCII אז בטוח מספיק, אתה תראה שr מיוצג על ידי 114.

434
00:32:03,010 --> 00:32:08,610
אז עכשיו אנחנו יודעים שאנחנו יכולים להוסיף מספרים שלמים לתווים, זה נראה די פשוט.

435
00:32:08,610 --> 00:32:12,740
אנחנו רק הולכים לחזר על מחרוזת כמו שראינו בדוגמה קודמת.

436
00:32:12,740 --> 00:32:17,170
אנחנו נבדוק אם זה מכתב.

437
00:32:17,170 --> 00:32:20,420
אם כן, אז להעביר אותו בכל מה שהמפתח הוא.

438
00:32:20,420 --> 00:32:23,650
די פשוט, למעט כאשר אתה מגיע לאוהב את זה,

439
00:32:23,650 --> 00:32:32,140
אתה רואה שz, מיוצג על ידי 122, אז היה נותן לך אופי שונה.

440
00:32:32,140 --> 00:32:37,770
אנחנו באמת רוצים להישאר במסגרת האלפבית שלנו, נכון?

441
00:32:37,770 --> 00:32:43,180
אז אנחנו צריכים למצוא דרך כלשהי מסוג של גלישה מסביב.

442
00:32:43,180 --> 00:32:47,190
כאשר אתם מגיעים zed ואתה רוצה להגדיל על ידי מספר מסוים,

443
00:32:47,190 --> 00:32:51,230
אתה לא רוצה להיכנס לקטע מעבר האלפבית ASCII;

444
00:32:51,230 --> 00:32:54,140
אתה רוצה לעטוף בחזרה את כל הדרך עד א '

445
00:32:54,140 --> 00:32:58,550
אבל יש לזכור שעדיין משמר את המקרה.

446
00:32:58,550 --> 00:33:00,980
אז הידיעה שמכתבים לא יכולה לסמל

447
00:33:00,980 --> 00:33:05,290
בדיוק כמו סמלים לא הולך להיות שינוי גם כן.

448
00:33:05,290 --> 00:33:08,170
בpset האחרון אתה בהחלט לא צריך,

449
00:33:08,170 --> 00:33:14,310
אבל אפשרות הייתה ליישם pset החמדן שלך על ידי שימוש בפונקצית מודולוס.

450
00:33:14,310 --> 00:33:17,230
אבל עכשיו אנחנו ממש הולכים צריכים להשתמש במודול,

451
00:33:17,230 --> 00:33:19,900
אז בואו נלך על זה קצת.

452
00:33:19,900 --> 00:33:26,920
בעיקרון, כאשר יש לך x מודולו y, שנותן לך את השארית של x החלק y.

453
00:33:26,920 --> 00:33:30,930
הנה כמה דוגמאות כאן. יש לנו 27% 15.

454
00:33:30,930 --> 00:33:36,200
בעיקרון, כאשר אתה להחסיר 15 מ 27 פעמים רבות ככל האפשר מבלי לקבל שלילי

455
00:33:36,200 --> 00:33:39,060
ואז אתה מקבל 12 שנשאר.

456
00:33:39,060 --> 00:33:44,650
אז זה כמו סוג של בהקשר המתמטיקה, אבל איך אנחנו יכולים להשתמש בזה?

457
00:33:44,650 --> 00:33:47,100
זה הולך להיות שימושי עבור wrapover.

458
00:33:47,100 --> 00:33:55,420
לשם כך, בואו רק נאמרתי ששאלתי את כל מה שאתה לחלק ל 3 קבוצות.

459
00:33:55,420 --> 00:33:58,010
לפעמים אתה עושה את זה בקבוצות ומשהו כזה.

460
00:33:58,010 --> 00:34:01,320
אגיד שאני אמרתי, "טוב, אני רוצה שכולכם להיות מחולק 3."

461
00:34:01,320 --> 00:34:04,240
כיצד תוכל לעשות זאת?

462
00:34:04,240 --> 00:34:06,810
[תגובת תלמיד לא ברורה] כן, בדיוק. התפקד. אוקיי.

463
00:34:06,810 --> 00:34:10,260
בואו לעשות את זה בפועל. האם אתה רוצה להתחיל?

464
00:34:10,260 --> 00:34:13,810
[תלמידים לספור את] 1, 2, 3, 4.

465
00:34:13,810 --> 00:34:16,620
אבל תזכור ... >> [תלמיד] אה, סליחה.

466
00:34:16,620 --> 00:34:18,730
זו נקודה ממש טובה.

467
00:34:18,730 --> 00:34:24,130
אתה אמרת 4, אבל אנחנו ממש רוצים שתגידו 1 כי אנחנו רוצים 3 קבוצות בלבד.

468
00:34:24,130 --> 00:34:30,159
אז, איך - לא, זה דוגמה ממש טובה כי אז איך אתה יכול לומר 1?

469
00:34:30,159 --> 00:34:33,370
מה הקשר בין 4 ו 1?

470
00:34:33,370 --> 00:34:36,760
ובכן, 4 mod 3 הוא 1.

471
00:34:36,760 --> 00:34:41,460
אז אם אתה ממשיך, אתה יהיה 2.

472
00:34:41,460 --> 00:34:44,540
אז יש לנו 1, 2, 3, 1, 2.

473
00:34:44,540 --> 00:34:49,420
שוב, אתה בעצם האדם 5. איך אתה יודע להגיד 2 במקום 5?

474
00:34:49,420 --> 00:34:53,760
אתה אומר 5 mod 3 הוא 2.

475
00:34:53,760 --> 00:34:59,100
אני רוצה לראות כמה קבוצות של 3 נותרים מעל, אז שכדי am I.

476
00:34:59,100 --> 00:35:02,860
ואם כך, אילו המשיך לאורך כל החדר,

477
00:35:02,860 --> 00:35:07,760
אז הייתי רואה שאנחנו תמיד למעשה יישום פונקצית mod לעצמנו

478
00:35:07,760 --> 00:35:09,990
סוג של להתפקד.

479
00:35:09,990 --> 00:35:14,490
גם זה סוג של דוגמה מוחשית יותר של איך אתה יכול להשתמש במודולו

480
00:35:14,490 --> 00:35:17,960
כי אני בטוחה שרובנו כנראה עברתי כי תהליך

481
00:35:17,960 --> 00:35:19,630
איפה שהיינו לנו לספור את.

482
00:35:19,630 --> 00:35:21,840
כל שאלות במודולו?

483
00:35:21,840 --> 00:35:25,360
זה יהיה די חשוב להבין את המושגים של זה,

484
00:35:25,360 --> 00:35:28,640
אז אני רוצה לוודא שאתם מבינים.

485
00:35:28,640 --> 00:35:34,660
[תלמיד] אם אין שארית, זה ייתן לך את המספר האמיתי?

486
00:35:34,660 --> 00:35:40,430
אם אחד מ3 הראשונים שלהם עשה את זה, זה היה נותן להם את מה שהם באמת היו,

487
00:35:40,430 --> 00:35:43,310
או שזה נתן להם [לא ברור] >> זו שאלה טובה.

488
00:35:43,310 --> 00:35:48,750
כאשר אין שארית למודולו - כך אומר שיש לך 6 mod 3 -

489
00:35:48,750 --> 00:35:52,340
שבעצם נותן לך גב 0.

490
00:35:53,670 --> 00:35:57,290
נידבר על זה קצת מאוחר יותר.

491
00:35:58,810 --> 00:36:07,720
אה, כן, למשל, האדם 3 - 3 mod 3 הוא למעשה 0 אבל היא אמרה 3.

492
00:36:07,720 --> 00:36:14,900
אז זה כמו סוג של מלכוד פנימי, למשל,

493
00:36:14,900 --> 00:36:17,620
כמו בסדר, אם mod הוא 0 אז אני הולך להיות האדם 3.

494
00:36:17,620 --> 00:36:22,740
אבל נעשה לנו סוג של איך יתכן שעלינו להתמודד עם מה 0 הוא מאוחר יותר.

495
00:36:22,740 --> 00:36:32,750
אז עכשיו אנחנו איכשהו יש דרך מיפוי zed לאות הנכונה.

496
00:36:32,750 --> 00:36:34,920
אז עכשיו שעברנו כל הדוגמות הללו,

497
00:36:34,920 --> 00:36:37,880
אנחנו סוג של לראות איך קיסר יכול לעבוד.

498
00:36:37,880 --> 00:36:42,640
אתה רואה את 2 אותיות ואז אתה רואה אותם משתנה.

499
00:36:42,640 --> 00:36:44,430
אז בואו ננסה ולבטא את זה במונחים של נוסחה.

500
00:36:44,430 --> 00:36:46,940
נוסחה זו היא למעשה שניתן לך במפרט,

501
00:36:46,940 --> 00:36:52,070
אבל סוג בואו של מבט דרך מה כל משתנה משמעות.

502
00:36:52,070 --> 00:36:55,000
התוצאה הסופית שלנו הולכת להיות מוצפנת.

503
00:36:55,000 --> 00:36:58,300
אז זה אומר שהאופי של ith המוצפן

504
00:36:58,300 --> 00:37:02,500
הולך מתאים לאופי ith של הטקסט.

505
00:37:02,500 --> 00:37:08,130
זה הגיוני, כי אנחנו רוצים להיות תמיד הזדנבות את הדברים האלה.

506
00:37:08,130 --> 00:37:13,480
אז זה הולך להיות דמות ith של המוצפן התוספת k, שהוא המפתח שלנו -

507
00:37:13,480 --> 00:37:17,230
זה הגיוני - ואז יש לנו 26 mod זה.

508
00:37:17,230 --> 00:37:19,860
זכור בחזרה כאשר היו לנו zed

509
00:37:19,860 --> 00:37:24,190
אנחנו לא רוצים להיכנס לאופי, אז רציתי mod זה

510
00:37:24,190 --> 00:37:26,540
וסוג של עוטף את האלפבית.

511
00:37:26,540 --> 00:37:33,430
לאחר zed שהיית הולך אל א, ב, ג, ד, עד שהגעת למספר הנכון.

512
00:37:33,430 --> 00:37:44,690
אז אנחנו יודעים שzed, אם + 6, היה נותנים לנו F כי אחרי zed מגיע, B, C, D, E, F.

513
00:37:44,690 --> 00:37:52,530
אז הבה נזכור שאנו יודעים בודאות כי zed + 6 הוא הולך לתת לנו f.

514
00:37:52,530 --> 00:38:03,530
בערכי ASCII, z הוא 122 ו f היא 102.

515
00:38:03,530 --> 00:38:10,570
אז אנחנו צריכים למצוא איזו דרך לעשות נוסחת הקיסר שלנו נותנים לנו 102

516
00:38:10,570 --> 00:38:13,590
לאחר שלקח ב122.

517
00:38:13,590 --> 00:38:19,550
אז אם רק ליישם את הנוסחא הזו,% (צ'+ 6) 26, שבעצם נותנים לך 24

518
00:38:19,550 --> 00:38:25,980
בגלל 122 + 6 הם 128; 128% 26 נותנים לך 24 שארית.

519
00:38:25,980 --> 00:38:29,140
אבל זה לא באמת מתכוון f. זה בהחלט לא 102.

520
00:38:29,140 --> 00:38:33,590
זה גם לא המכתב 6 באלף הבית.

521
00:38:33,590 --> 00:38:41,550
אז ברור, שאנחנו צריכים לעבור כמה דרך של tweaking זה קצת.

522
00:38:42,970 --> 00:38:51,340
במונחים של האלפבית הרגיל, אנו יודעים כי z הוא האות 26 ו-F הוא 6.

523
00:38:51,340 --> 00:38:55,460
אבל אנחנו במדעי מחשב, ולכן אנחנו הולכים למדד ב 0.

524
00:38:55,460 --> 00:39:00,690
אז במקום z להיות המספר 26, אנחנו הולכים להגיד את המספר שלו 25

525
00:39:00,690 --> 00:39:02,630
כי הוא 0.

526
00:39:02,630 --> 00:39:04,770
אז עכשיו בואו ננסה להפעיל את הנוסחא הזאת.

527
00:39:04,770 --> 00:39:11,710
יש לנו z מיוצג על ידי 25 + 6, אשר נותן לך 31.

528
00:39:11,710 --> 00:39:15,790
ו31 mod 26 נותן לך 5 כשארית.

529
00:39:15,790 --> 00:39:20,500
זה מושלם, כי אנחנו יודעים שf הוא 5 המכתב באלפבית.

530
00:39:20,500 --> 00:39:26,400
אבל זה עדיין לא F, נכון? זה עדיין לא 102.

531
00:39:26,400 --> 00:39:32,730
אז לpset זה, אתגר יהיה בניסיון לברר את הקשר

532
00:39:32,730 --> 00:39:36,910
בין ההמרה בין הערכים אלה ASCII ומדד אלפביתי.

533
00:39:36,910 --> 00:39:40,280
בעיקרו של דבר, מה שאתה רוצה לעשות, אתה רוצה לצאת לדרך עם ערכי ASCII,

534
00:39:40,280 --> 00:39:45,390
אבל אז אתה רוצה איכשהו צריך לתרגם את זה לאינדקס אלפביתי

535
00:39:45,390 --> 00:39:52,610
לאחר מכן לחשב מה מכתב זה צריך להיות - בעצם, מה האינדקס אלפביתי שלה הוא

536
00:39:52,610 --> 00:39:57,660
של אופי הצופן - ולאחר מכן לתרגם את זה בחזרה לערכי ASCII.

537
00:39:57,660 --> 00:40:04,870
אז אם אתה לשלוף טבלת ASCII שלך, ואז לנסות ולמצוא יחסים בין, תניח, 102 ו 5

538
00:40:04,870 --> 00:40:10,440
או 122 ו 25.

539
00:40:12,140 --> 00:40:15,690
Gotten המפתח שלנו מטיעוני שורת הפקודה, קבל הטקסט,

540
00:40:15,690 --> 00:40:17,520
אנחנו כבר הצפנו אותו.

541
00:40:17,520 --> 00:40:19,820
עכשיו כל מה שנותרנו לנו לעשות הוא להדפיס אותו.

542
00:40:19,820 --> 00:40:22,040
אנחנו יכולים לעשות את זה כמה דרכים שונות.

543
00:40:22,040 --> 00:40:24,570
מה שאנחנו יכולים לעשות הוא למעשה להדפיס כמו שאנחנו הולכים יחד.

544
00:40:24,570 --> 00:40:28,250
ככל שנעמיק יותר את התווים במחרוזת,

545
00:40:28,250 --> 00:40:31,660
אנחנו פשוט יכולים פשוט להדפיס באותו רגע, כאשר אנו מחשבים אותו.

546
00:40:31,660 --> 00:40:36,030
לחלופין, אתה יכול גם לאחסן אותו במערך ויש מערך של תווים

547
00:40:36,030 --> 00:40:39,280
ובסופו לחזר על שכל המערך ולהדפיס אותו.

548
00:40:39,280 --> 00:40:40,980
אז יש לך כמה אפשרויות לכך.

549
00:40:40,980 --> 00:40:47,280
ותזכור ש% ג הולך להיות המקום עבור הדפסת תו.

550
00:40:47,280 --> 00:40:50,420
אז יש לנו את קיסר, ועכשיו אנחנו עוברים לVigenere,

551
00:40:50,420 --> 00:40:57,580
אשר דומה מאוד לקיסר אלא רק מעט יותר מורכב.

552
00:40:57,580 --> 00:41:03,310
אז בעצם עם Vigenere הוא שאתה הולך להיות עובר במילת מפתח.

553
00:41:03,310 --> 00:41:06,510
אז במקום מספר, אתה הולך להיות מחרוזת,

554
00:41:06,510 --> 00:41:09,200
וכך זה הולך לפעול כמילת המפתח שלך.

555
00:41:09,200 --> 00:41:14,440
ואז, כרגיל, אתה הולך לקבל את הבקשה למחרוזת מהמשתמש

556
00:41:14,440 --> 00:41:19,050
ואז להצפין אותו ואז לתת להם בחזרה המוצפן.

557
00:41:19,050 --> 00:41:24,650
אז כמו שאמרתי, זה דומה מאוד לקיסר, אלא שבמקום תפנית של מספר מסוים,

558
00:41:24,650 --> 00:41:30,620
המספר הוא בעצם הולך לשנות כל פעם מדמה לדמות.

559
00:41:30,620 --> 00:41:34,890
לייצג שמספר אמיתי להעביר, זה מיוצג על ידי אותיות המקלדת.

560
00:41:34,890 --> 00:41:43,150
אז אם אתם נכנסים במשמרת של, למשל, אז זה יהיה מתאים לשינוי של 0.

561
00:41:43,150 --> 00:41:45,900
אז זה שוב חוזר למדד אלפביתי.

562
00:41:45,900 --> 00:41:49,100
מה יכול להיות שימושי אם אתה רואה שאנחנו בעצם מתעסקים עם ערכי ASCII

563
00:41:49,100 --> 00:41:51,790
כמו גם את המכתבים, כמו גם ראשי אלפביתי,

564
00:41:51,790 --> 00:41:58,020
אולי למצוא או ליצור טבלת ASCII משלך המציגה את האינדקס אלפביתי של 0 עד 25,

565
00:41:58,020 --> 00:42:03,750
עד Z, ​​ואת ערכי ASCII, כך שאתה יכול לראות סוג של מערכת היחסים

566
00:42:03,750 --> 00:42:07,020
ולשרטט ולנסות ולמצוא כמה דפוסים.

567
00:42:07,020 --> 00:42:11,010
בדומה לכך, אם היית עובר במקרה המסוים על ידי ו -

568
00:42:11,010 --> 00:42:21,110
וזה או הוא או f הקטן או אותיות רישיות - אז זה יהיה מתאים ל5.

569
00:42:21,110 --> 00:42:24,180
האם אנחנו טובים עד כה?

570
00:42:25,770 --> 00:42:30,050
הנוסחא לVigenere היא קצת שונה.

571
00:42:30,050 --> 00:42:32,960
בעיקרון, אתה רואה שזה בדיוק כמו קיסר,

572
00:42:32,960 --> 00:42:37,390
רק שבמקום רק k יש לנו k ראשי j.

573
00:42:37,390 --> 00:42:44,810
שימו לב שאנו לא משתמשים אני כי בעצם, באורך של מילת המפתח

574
00:42:44,810 --> 00:42:49,850
הוא לא בהכרח האורך של ההודעה המוצפנת שלנו.

575
00:42:49,850 --> 00:42:56,130
זה יהיה יותר ברור קצת, כאשר אנו רואים דוגמה לכך שיש לי קצת יותר מאוחר.

576
00:42:56,130 --> 00:43:03,160
בעיקרון, אם אתה מפעיל את התכנית שלך עם מילת מפתח של Ohai,

577
00:43:03,160 --> 00:43:08,560
אז זה אומר שכל פעם, Ohai הולכת להיות המשמרת שלך.

578
00:43:08,560 --> 00:43:11,060
אז תלוי מה עמדתך היא במילת המפתח שלך,

579
00:43:11,060 --> 00:43:15,800
אתה הולך להעביר את האופי המוצפן המסוים בסכום זה.

580
00:43:15,800 --> 00:43:19,630
שוב, בדיוק כמו קיסר, אנחנו רוצים לוודא שאנחנו משמרים את השווי של דברים

581
00:43:19,630 --> 00:43:22,900
ואנחנו רק אותיות הצפן, לא תווים או רווחים.

582
00:43:22,900 --> 00:43:26,330
אז מסתכל אחורה לקיסר על הפונקציות שייתכן שהשתמש בם,

583
00:43:26,330 --> 00:43:32,570
הדרך שאתה החלטת כיצד להעביר את הדברים, וליישם את זה לתכנית שלך כאן.

584
00:43:32,570 --> 00:43:35,260
אז בואו למפות את זה.

585
00:43:35,260 --> 00:43:39,680
יש לנו טקסט שקבלנו מהמשתמש מGetString

586
00:43:39,680 --> 00:43:44,090
אומר את זה ... הוא CS50!

587
00:43:44,090 --> 00:43:47,090
אז יש לנו מילת מפתח של Ohai.

588
00:43:47,090 --> 00:43:50,930
את 4 התווים הראשונים הם די פשוט.

589
00:43:50,930 --> 00:43:55,580
אנו יודעים כי T הולך להיות מוזז על ידי o,

590
00:43:55,580 --> 00:44:01,990
אז h הולך להיות מוזז על ידי ח, אני הולך להיות מוזז על ידי.

591
00:44:01,990 --> 00:44:04,610
כאן אתה רואה שמייצג 0,

592
00:44:04,610 --> 00:44:11,940
כן אז הערך הסופי הוא למעשה רק אותו המכתב כמו קודם.

593
00:44:11,940 --> 00:44:15,250
אז שלו הוסט על ידי א.

594
00:44:15,250 --> 00:44:19,370
אבל אז יש לך תקופות אלו כאן.

595
00:44:19,370 --> 00:44:25,960
אנחנו לא רוצים בצופן ש, אז אנחנו לא לשנות אותו על ידי שום דבר

596
00:44:25,960 --> 00:44:31,280
ופשוט להדפיס את התקופה ללא שינוי.

597
00:44:31,280 --> 00:44:38,020
[תלמיד] אני לא מבין איך אתה יודע שזה מוזז על ידי - מאיפה אתה - >> אה, סליחה.

598
00:44:38,020 --> 00:44:41,620
בראש כאן אתה רואה שOhai שורת פקודת הוויכוח כאן,

599
00:44:41,620 --> 00:44:43,740
שהולך להיות מילת המפתח.

600
00:44:43,740 --> 00:44:49,550
וכך בעצם, אתה רכבת על אופניים בדמויות במילת המפתח.

601
00:44:49,550 --> 00:44:52,020
[תלמיד] o אז הוא הולך להיות הסטה אותו הדבר -

602
00:44:52,020 --> 00:44:56,260
אז o מתאים למספר מסוים באלף הבית.

603
00:44:56,260 --> 00:44:58,400
[תלמיד] ימני. אבל איפה השגת את CS50 חלק מ?

604
00:44:58,400 --> 00:45:02,540
אה. זה בGetString בי אתה כמו, "תן לי את מחרוזת לקידוד".

605
00:45:02,540 --> 00:45:07,510
[תלמיד] הם הולכים לתת לך טיעון שכדי להסיט

606
00:45:07,510 --> 00:45:09,380
ואז תשאלו למחרוזת הראשונה שלך. >> כן.

607
00:45:09,380 --> 00:45:12,440
אז כשהם מפעילים את התכנית, הם הולכים לכלול את מילת המפתח

608
00:45:12,440 --> 00:45:14,740
בטיעוני שורת הפקודה שלהם כשהם נתקלים בו.

609
00:45:14,740 --> 00:45:19,740
ואז ברגע שבדקת שהם נתנו לך 1 בפועל ולא יותר, לא פחות,

610
00:45:19,740 --> 00:45:23,750
ואז אתה הולך לתנחה אותם למחרוזת, אומר, "תן לי חבל".

611
00:45:23,750 --> 00:45:27,630
אז לשם במקרה זה הם נתנו לך זה ... הוא CS50!

612
00:45:27,630 --> 00:45:32,090
אז אתה הולך להשתמש בזה ומשתמש בOhai ולחזר על.

613
00:45:32,090 --> 00:45:38,200
שים לב שכאן אנחנו פוסחים על הצפנת התקופות,

614
00:45:38,200 --> 00:45:51,660
אבל במונחים של עמדתנו לOhai, אחד ליד השתמשנו O.

615
00:45:51,660 --> 00:45:54,990
במקרה הזה זה קצת יותר קשה לראות כי זה 4,

616
00:45:54,990 --> 00:45:57,710
אז בואו נמשיך קצת. פשוט להישאר עימי כאן.

617
00:45:57,710 --> 00:46:02,960
אז יש לנו אני וים, ולאחר מכן שמתורגמים על ידי o וח בהתאמה.

618
00:46:02,960 --> 00:46:09,370
אז יש לנו חלל, וכך אז אנחנו יודעים שאנחנו לא הולכים בצופן את הרווחים.

619
00:46:09,370 --> 00:46:18,930
אבל שים לב שבמקום ללכת למקום זה ממש כאן,

620
00:46:18,930 --> 00:46:28,330
אנחנו הצפנה על ידי - אני לא יודע אם אתה יכול לראות את זה - ממש כאן.

621
00:46:28,330 --> 00:46:33,710
אז זה לא מתאים לך מראש בעצם, אומר, o הולכת כאן, h הולך כאן,

622
00:46:33,710 --> 00:46:39,200
הולך כאן, אני הולך כאן, o h,, I, O, h,, אני. אתה לא עושה את זה.

623
00:46:39,200 --> 00:46:43,760
אתה לשנות את התנוחה שלך רק במילות המפתח

624
00:46:43,760 --> 00:46:51,020
כשאתה יודע שאתה בעצם הולך להיות הצפנת מכתב בפועל.

625
00:46:51,020 --> 00:46:53,920
האם זה סוג של היגיון?

626
00:46:53,920 --> 00:46:55,800
אוקיי.

627
00:46:56,490 --> 00:46:58,500
אז רק כמה תזכורות.

628
00:46:58,500 --> 00:47:03,760
אתה רוצה לוודא שאתה להתקדם רק לאות הבאה במילת המפתח שלך

629
00:47:03,760 --> 00:47:06,390
אם הדמות בטקסט שלך היא מכתב.

630
00:47:06,390 --> 00:47:09,120
אז להגיד שאנחנו בo.

631
00:47:09,120 --> 00:47:19,310
אנו מבחינים כי התו הבא, במדד שלי בטקסט, הוא מספר, למשל.

632
00:47:19,310 --> 00:47:31,630
אז אנחנו לא מתקדמים j, מדד למילות המפתח שלנו, עד שנגיע מכתב נוסף.

633
00:47:31,630 --> 00:47:36,230
שוב, אתה גם רוצה לוודא שאתה מעטפת לתחילת מילת המפתח

634
00:47:36,230 --> 00:47:37,770
כאשר אתה נמצא בסופו.

635
00:47:37,770 --> 00:47:42,030
אם אתה רואה כאן אנחנו באני, הבא צריך להיות O.

636
00:47:42,030 --> 00:47:47,690
אז אתה רוצה למצוא דרך של יכולת מעטפת לתחילת מילת המפתח שלך

637
00:47:47,690 --> 00:47:49,470
בכל פעם שאתה מגיע לסוף.

638
00:47:49,470 --> 00:47:55,040
וכך שוב, איזה סוג של מפעיל הוא שימושי במקרה זה לגלישה סביב?

639
00:47:56,630 --> 00:47:59,840
כמו בספירה את הדוגמא.

640
00:47:59,840 --> 00:48:03,710
[התלמיד] סימן האחוזים. >> כן, סימן האחוזים, שהוא מודולו.

641
00:48:03,710 --> 00:48:11,250
אז מודולו יהיה שימושי כאן כאשר אתה רוצה לעטוף לעומת המדד בOhai.

642
00:48:11,250 --> 00:48:17,700
ורק רמז מהיר: נסה לחשוב על עטיפה מעל מילת המפתח קצת כמו את הספירה,

643
00:48:17,700 --> 00:48:23,590
שבו אם יש 3 קבוצות, האדם 4,

644
00:48:23,590 --> 00:48:30,610
מספרם שהם אמרו שהיה 4 mod 3, שהיה 1.

645
00:48:30,610 --> 00:48:32,880
אז לנסות ולחשוב על זה ככה.

646
00:48:34,770 --> 00:48:42,740
כפי שראית בנוסחה, בכל מקום שיש לך ולאחר מכן ci pi אבל אז KJ,

647
00:48:42,740 --> 00:48:44,700
אתה רוצה לוודא שאתה לעקוב אחר אלה.

648
00:48:44,700 --> 00:48:47,580
אתה לא צריך לקרוא לזה אני, אתה לא צריך לקרוא לזה j,

649
00:48:47,580 --> 00:48:53,270
אבל אתה רוצה לוודא שאתה לעקוב אחר העמדה שאתה נמצא בבית בטקסט שלך

650
00:48:53,270 --> 00:48:55,790
כמו גם העמדה שאתה נמצא בבית במילת המפתח שלך

651
00:48:55,790 --> 00:48:59,840
כי אלה לא בהכרח הולכים להיות אותו הדבר.

652
00:48:59,840 --> 00:49:06,400
לא רק את מילת המפתח - זה יכול להיות באורך שונה לחלוטין מהטקסט שלך.

653
00:49:06,400 --> 00:49:09,140
כמו כן, בטקסט שלך, יש מספרים ותווים,

654
00:49:09,140 --> 00:49:14,450
כך שזה לא הולך להתאים יחד באופן מושלם. כן.

655
00:49:14,450 --> 00:49:19,280
[תלמיד] האם יש פונקציה לשינוי מצב?

656
00:49:19,280 --> 00:49:24,530
האם אתה יכול לשנות לבירה? >> כן, יש בהחלט.

657
00:49:24,530 --> 00:49:27,890
אתה יכול לבדוק - אני מאמין toupper זה, כל המילה 1.

658
00:49:30,650 --> 00:49:36,310
אבל כאשר אתה מנסה צופן דברים ולשמר את הטקסט,

659
00:49:36,310 --> 00:49:39,350
זה הכי טוב בעיקרון יש מקרים נפרדים.

660
00:49:39,350 --> 00:49:42,040
אם זה באותיות גדולה, ואז אתה רוצה להעביר את זה על ידי

661
00:49:42,040 --> 00:49:46,460
כי בנוסחא שלך, כשאתה מסתכל אחורה כמה שיש לנו לסוג של דרכים

662
00:49:46,460 --> 00:49:50,900
לסירוגין בין דרך ASCII של המספרים המייצגים את

663
00:49:50,900 --> 00:49:55,020
ומדד אלפביתי בפועל, אנו רוצים לוודא

664
00:49:55,020 --> 00:50:01,850
יש הולך להיות איזה דפוס שאתה הולך להשתמש.

665
00:50:01,850 --> 00:50:04,580
עוד הערה על הדפוס, בעצם.

666
00:50:04,580 --> 00:50:07,250
אתה הולך בהחלט להיות התמודדות עם מספרים.

667
00:50:07,250 --> 00:50:11,280
נסה לא להשתמש במספר קסם, שהוא דוגמה לסגנון.

668
00:50:11,280 --> 00:50:18,470
אז אומר שאתה רוצה משהו בכל עת על ידי שינוי אוהב -

669
00:50:18,470 --> 00:50:22,400
אוקיי, אז רמז, ספוילר נוסף הוא כאשר אתה הולך להיות משהו משתנה

670
00:50:22,400 --> 00:50:26,310
במידה מסוימת, נסה לא מייצג שעל ידי מספר בפועל

671
00:50:26,310 --> 00:50:32,810
אלא לנסות ולראות אם אתה יכול להשתמש בערך ASCII, שסוג של הגיוני יותר.

672
00:50:32,810 --> 00:50:35,470
הערה נוספת: מכיוון שיש לנו עסק עם נוסחות,

673
00:50:35,470 --> 00:50:41,200
למרות TF יהיה סוג של דפוס יודע מה אתה יכול להיות באמצעות,

674
00:50:41,200 --> 00:50:44,430
הכי טוב בסוג של ההערות שלך להסביר את ההיגיון, אוהב,

675
00:50:44,430 --> 00:50:51,880
"אני משתמש בדפוס זה בגלל ..." וסוג של להסביר את הדפוס בתמציתיות את הערותיך.

676
00:50:54,090 --> 00:50:58,990
[זו הייתה הדרכה 2] אם אין עוד שאלות, אז אני פשוט אשאר כאן לקצת.

677
00:50:58,990 --> 00:51:04,370
בהצלחה עם pset 2: האנוסים ותודה שבאת.

678
00:51:06,070 --> 00:51:08,620
[תלמיד] תודה לך. תודה. >>

679
00:51:09,220 --> 00:51:10,800
[הקדמה מנותקת מדיה]