1
00:00:00,000 --> 00:00:11,980

2
00:00:11,980 --> 00:00:16,980
>> ROB: היי, אני רוב, ובוא לפענח
תכנית Vigenere.

3
00:00:16,980 --> 00:00:21,180
הדבר אז קודם כל שאנחנו צריכים לעשות הוא להפוך את
בטוח שהמשתמש נכנס למה שציפינו

4
00:00:21,180 --> 00:00:23,240
אותם בשורת הפקודה.

5
00:00:23,240 --> 00:00:28,720
כך שאם argc הוא לא 2 פירושו
המשתמש לא נכנס לנו המחרוזת

6
00:00:28,720 --> 00:00:31,780
רוצה להיות משתמש כמו ההצפנה שלנו
מחרוזת, או שהם

7
00:00:31,780 --> 00:00:32,890
נכנס יותר מדי דברים.

8
00:00:32,890 --> 00:00:35,130
ואנחנו לא יודעים מה לעשות
עם אלה דברים אחרים.

9
00:00:35,130 --> 00:00:37,960
>> אז אנחנו אומרים להם את מה שהם
היה צריך להיות נכנס.

10
00:00:37,960 --> 00:00:39,300
ואנחנו חוזרים.

11
00:00:39,300 --> 00:00:44,570
עכשיו, בהנחה שתכנית + הייתה 2, אנחנו יכולים
תמשיך עם שאר התכנית.

12
00:00:44,570 --> 00:00:47,890
>> אנו כינוי שמו של argv [1]

13
00:00:47,890 --> 00:00:49,750
למילת מפתח משתנה.

14
00:00:49,750 --> 00:00:51,860
כך שאנחנו לא צריכים
להשתמש בשם argv [1]

15
00:00:51,860 --> 00:00:53,050
בכל שאר התכנית.

16
00:00:53,050 --> 00:00:55,570
ואולי יהיה לנו לשכוח את מה
זה אומר וכן הלאה.

17
00:00:55,570 --> 00:00:57,830
מילת המפתח הוא שם הרבה יותר נחמד.

18
00:00:57,830 --> 00:01:01,982
ואנו תופסים את האורך מייד
של מילות המפתח שלנו כאן.

19
00:01:01,982 --> 00:01:07,460
>> אוקיי, אז עכשיו אנחנו רוצים לבדוק כי
מילת המפתח שלנו הוא חוקית למעשה.

20
00:01:07,460 --> 00:01:11,250
מילת המפתח שאנו משתמשים כדי להצפין מחרוזות
פשוט צריך להיות אלפביתי

21
00:01:11,250 --> 00:01:12,400
תווים.

22
00:01:12,400 --> 00:01:16,830
אם המשתמש נכנס שאינו אלפביתי
דמויות, אנחנו צריכים לומר, מילות מפתח

23
00:01:16,830 --> 00:01:20,170
חייב להכיל רק דרך
Z ולאחר מכן לחזור.

24
00:01:20,170 --> 00:01:24,370
אז זה בשביל סובב רצף על פני כל
תווים של מילות המפתח שלנו, בודק

25
00:01:24,370 --> 00:01:31,870
כי אם הוא לא אלפביתי אז
אנחנו צריכים להדפיס אזהרה ש.

26
00:01:31,870 --> 00:01:36,285
>> עכשיו, ברגע שנגיע לנקודה זו, שאנו מכירים
שהמחרוזת חייבת להיות נכונה.

27
00:01:36,285 --> 00:01:38,230
מילת המפתח חייבת להיות נכונה.

28
00:01:38,230 --> 00:01:40,880
ועכשיו אנחנו צריכים לקבל הודעה מ
המשתמש שהם רוצים אותנו

29
00:01:40,880 --> 00:01:43,910
להצפין עם זה משפט המפתח.

30
00:01:43,910 --> 00:01:46,780
אז כדי לקבל את המסר הזה, שיש לנו
לעשות בזמן לולאה שהולכת

31
00:01:46,780 --> 00:01:52,650
ברציפות מקבל מחרוזת מהמשתמש
עד שנכנסים למחרוזת חוקית.

32
00:01:52,650 --> 00:01:58,690
>> בהמשך, אנו רואים כאן במשתנה זה,
int nun_letters_seen.

33
00:01:58,690 --> 00:02:01,300
אנחנו תראו למה אנחנו צריכים
כי בשנייה.

34
00:02:01,300 --> 00:02:07,320
אבל זה ללולאה הולך לחזר
מאני שווה 0 כל הדרך עד לi

35
00:02:07,320 --> 00:02:10,940
שווה n, מה שאומר שאנחנו iterating
על כל אפשרי

36
00:02:10,940 --> 00:02:13,020
דמויות במסר שלנו.

37
00:02:13,020 --> 00:02:17,370
מכיוון שאנחנו רוצים להצפין את כל
הדמויות במסר שלנו.

38
00:02:17,370 --> 00:02:22,970
אז שם לב שאנחנו עושים אם (isalphamessage [אני],
בגלל שאנחנו לא רוצים להצפין

39
00:02:22,970 --> 00:02:25,660
תווים שאינם אלפביתי.

40
00:02:25,660 --> 00:02:28,810
אם יש סימנים, מרחבים,
או במספרים, אנחנו לא

41
00:02:28,810 --> 00:02:30,730
רוצה להצפין אותם.

42
00:02:30,730 --> 00:02:37,220
>> עכשיו, בהנחה שזה אלפביתי,
אנחנו רוצים קודם להבין מה אנחנו

43
00:02:37,220 --> 00:02:40,890
בעצם רוצה להצפין
ההודעה באמצעות.

44
00:02:40,890 --> 00:02:42,710
אז מה אני מתכוון לעשות את זה?

45
00:02:42,710 --> 00:02:46,740
>> הבה יניחו כי משפט המפתח
המשתמש נכנס היה abc.

46
00:02:46,740 --> 00:02:49,070
זה מה שאנחנו משתמשים להצפנה.

47
00:02:49,070 --> 00:02:54,850
עכשיו, בתמימות, שאנחנו חושבים שזה אומר ש
אנחנו רוצים להצפין את התו הראשון

48
00:02:54,850 --> 00:02:59,740
המסר שלנו על ידי 0, שכן אמצעי
מסתובב האופי של 0.

49
00:02:59,740 --> 00:03:04,395
>> אנחנו רוצים להצפין את התו השני
על ידי 1, דמות שלישית ב -2,

50
00:03:04,395 --> 00:03:09,170
הדמות הרביעית של 0, החמישי
על ידי 1, שישי על ידי 2, וכן הלאה.

51
00:03:09,170 --> 00:03:14,440
אך יש לזכור, כי אנו רוצים לדלג
רווחים וסימנים ומספרים.

52
00:03:14,440 --> 00:03:21,520
משמעות דבר היא שאם המשתמש נכנס
שלום עולם כהודעה

53
00:03:21,520 --> 00:03:26,590
כי הם רוצים להצפין, ולאחר מכן
אנחנו רוצים להצפין את שעות של 0

54
00:03:26,590 --> 00:03:32,680
מתאים ל, הדואר על ידי 1,
l על ידי 2, l ב 0, o על ידי 1.

55
00:03:32,680 --> 00:03:41,050
אנחנו רוצים לדלג על החלל, מוצפן
w על ידי 2, o ב 0, 1, 2, 0.

56
00:03:41,050 --> 00:03:45,250
אז שם לב, אם היינו לנו לא פסחנו
שטח, ולאחר מכן היינו מוצפן

57
00:03:45,250 --> 00:03:51,240
w של 0 ובסופו של דבר עם
המחרוזת שגויה.

58
00:03:51,240 --> 00:03:57,470
>> אוקיי, זה מה שאנחנו צריכים משתנים
num_letters_seen ל.

59
00:03:57,470 --> 00:04:04,450
אם היינו פשוט הולכים להצפנה באמצעות
בשיטה זו, שאינה לדלג

60
00:04:04,450 --> 00:04:09,860
סמלים, חללים, ומספרים, אז אנחנו
יכול פשוט להשתמש במשתנה i כמה

61
00:04:09,860 --> 00:04:12,540
לאינדקס לתוך משפט המפתח שלנו עם.

62
00:04:12,540 --> 00:04:17,620
אנחנו צריכים להשתמש בnum_letters_seen לשמור
אחר המקום בפועל ב

63
00:04:17,620 --> 00:04:21,146
משפט מפתח שאנחנו רוצים למדד.

64
00:04:21,146 --> 00:04:32,240
אז הנה, אם מילת המפתח שיש לנו, אם
num_letter_seen keyword_length mod, כך

65
00:04:32,240 --> 00:04:34,570
למה אנחנו צריכים mod
לפי אורך מילת מפתח?

66
00:04:34,570 --> 00:04:36,630
>> ובכן, שלום העולם היה דוגמא טובה.

67
00:04:36,630 --> 00:04:42,310
אם מילת המפתח היה abc, אז אנחנו צריכים
כדי להצפין ברציפות על ידי ולאחר מכן ב

68
00:04:42,310 --> 00:04:45,740
לאחר מכן ג, ולאחר מכן לעטוף בחזרה בסביבה,
א, ב, ג, א, ב, ג.

69
00:04:45,740 --> 00:04:50,110
אז אנחנו צריכים mod על ידי אורך של מילות מפתח
כדי לעטוף חזרה בסביבה.

70
00:04:50,110 --> 00:04:57,280
>> אז אם זה אות גדולה,
אז אנחנו רוצים להצפין ידי

71
00:04:57,280 --> 00:05:01,450
עמדתו של המכתב שבאלף הבית,
שלו אנחנו מקבלים רק על ידי

72
00:05:01,450 --> 00:05:06,730
הפחתה את א הון ו
באופן דומה, לאותיות קטנות, אנחנו

73
00:05:06,730 --> 00:05:13,000
יכול לקבל את המפתח שאנחנו רוצים על ידי
הפחתה את אותיות קטנות.

74
00:05:13,000 --> 00:05:16,910
אז לא משנה אם את המכתב
במשפט המפתח היה הון או

75
00:05:16,910 --> 00:05:21,640
אות קטנה, אנחנו הולכים
להצפין באותו הסכום.

76
00:05:21,640 --> 00:05:28,680
>> עכשיו שיש לנו מפתח שלנו, שאנו רואים כאן,
שאם מסר שאני הוא רישיות

77
00:05:28,680 --> 00:05:32,660
אופי, אז אנחנו רוצים לחשב את
עמדה באלף הבית של ש

78
00:05:32,660 --> 00:05:39,460
דמות, להוסיף המפתח שלנו אליו, עוטף את הגב
סביב כל כך שאם עברו

79
00:05:39,460 --> 00:05:43,170
z אנחנו חוזרים ל, B, C וכן הלאה.

80
00:05:43,170 --> 00:05:49,070
ואז, סוף סוף, להוסיף חזרה על א הון אז
אנו משמרות בחזרה ל[? Ascii?]

81
00:05:49,070 --> 00:05:52,010
מגוון של דמויות אלה במקום
מיקום מספרי באלף הבית

82
00:05:52,010 --> 00:05:53,540
של דמויות אלה.

83
00:05:53,540 --> 00:05:56,610
>> ואנחנו עושים את אותו דבר עבור
מקרה תווים נמוכים יותר.

84
00:05:56,610 --> 00:06:00,070
מלבד אנחנו רוצים להחסיר את אותיות קטנות
ולהוסיף אותו מחדש ב

85
00:06:00,070 --> 00:06:02,900
הסוף, באותיות קטנה.

86
00:06:02,900 --> 00:06:08,120
שים לב num_letter_seen שרק
מוגדל אם הודעה הייתי

87
00:06:08,120 --> 00:06:09,640
אלפביתי.

88
00:06:09,640 --> 00:06:15,790
כך אנחנו מדלגים חללים, סמלים ו
מספרים במשפט המפתח שלנו, שכן

89
00:06:15,790 --> 00:06:20,520
num_letter_seen הוא מה שאנו משתמשים
למדד למילות המפתח שלנו.

90
00:06:20,520 --> 00:06:24,540
>> לבסוף, בסופו של הדבר, החברה הודעה כי
אני כבר מוצפן, אנחנו

91
00:06:24,540 --> 00:06:26,280
להדפיס את ההודעה i.

92
00:06:26,280 --> 00:06:27,890
וזהו זה.

93
00:06:27,890 --> 00:06:28,670
השם שלי הוא רוב.

94
00:06:28,670 --> 00:06:31,020
וזה Vigenere.

95
00:06:31,020 --> 00:06:32,850
>> [השמעת מוסיקה]

96
00:06:32,850 --> 00:06:36,651