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

2
00:00:11,960 --> 00:00:13,750
>> ROB אודן: היי, אני רוב.

3
00:00:13,750 --> 00:00:17,360
וכאשר ברומא, בואו של תכנית
כרומאי.

4
00:00:17,360 --> 00:00:22,280
לכן, דבר הראשון שאנחנו צריכים לעשות הוא לבדוק
כדי לוודא שהמשתמש נכנס למעשה

5
00:00:22,280 --> 00:00:26,670
המספר שאנחנו רוצים לסובב כל
אופי על ידי בשורת הפקודה.

6
00:00:26,670 --> 00:00:27,740
>> לכן, אנחנו בודקים.

7
00:00:27,740 --> 00:00:30,180
האם תכנית + שווה ל 2?

8
00:00:30,180 --> 00:00:34,190
אם זה לא, זה אומר שהמשתמש או
לא נכנס למספר ב

9
00:00:34,190 --> 00:00:37,770
שורת הפקודה או שהם נכנסו ליותר מדי
דברים בשורת הפקודה, שבו

10
00:00:37,770 --> 00:00:40,560
מקרה אנחנו לא יודעים מה לעשות
עם שאר הדברים.

11
00:00:40,560 --> 00:00:45,750
אז, כל עוד תכנית + הייתה שני, אנחנו יכולים
תמשיך עם שאר התכנית.

12
00:00:45,750 --> 00:00:49,610
>> עכשיו, זוכר שargv
1 תמיד חוט.

13
00:00:49,610 --> 00:00:52,490
אבל אנחנו רוצים להתייחס אליו כמספר שלם.

14
00:00:52,490 --> 00:00:57,550
לכן, אנו משתמשים בפונקצית atoi זה
מפרט סט עמ 'נזכר להמיר

15
00:00:57,550 --> 00:01:02,330
argv מחרוזת 1 למספר שלם,
ואנו מאחסנים שבמפתח.

16
00:01:02,330 --> 00:01:06,050
אנחנו רוצים לוודא שהמספר השלם
שנכנס הוא לא שלילי.

17
00:01:06,050 --> 00:01:09,490
ואם זה היה, אנחנו רוצים להדפיס, כי כדי
המשתמש שהם לא אפשר

18
00:01:09,490 --> 00:01:11,980
כדי לעשות את זה, ולחזור.

19
00:01:11,980 --> 00:01:15,100
>> אז, עכשיו יש לנו בתוקף
מספר מהמשתמש.

20
00:01:15,100 --> 00:01:19,780
אבל אנחנו צריכים לקבל מחרוזת מ
משתמש שאנחנו רוצים להצפין.

21
00:01:19,780 --> 00:01:25,340
אז אנחנו רגילים לעשות, ואילו לולאה ולהשתמש לקבל
מחרוזת כדי לקבל מחרוזת זו מ

22
00:01:25,340 --> 00:01:29,190
למשתמש, ולהמשיך לקבל מחרוזת
עד שהם למעשה

23
00:01:29,190 --> 00:01:31,270
הכנס מחרוזת חוקית.

24
00:01:31,270 --> 00:01:34,400
>> ברגע שיש לנו מחרוזת ש, אנחנו
יכול ללכת על מנת להצפין אותו.

25
00:01:34,400 --> 00:01:38,120
אז, ללולאה הזו עושה
הצפנה זו.

26
00:01:38,120 --> 00:01:43,250
שים לב שאנחנו iterating מאני
שווה 0 t כל הדרך עד שאני שווה

27
00:01:43,250 --> 00:01:47,790
n, כאשר n הוא מוגדר כאורכו של
המסר שלנו, שבו המסר הוא

28
00:01:47,790 --> 00:01:50,260
מחרוזת שהמשתמש נכנס.

29
00:01:50,260 --> 00:01:54,330
>> אז אנחנו iterating על כל
תווים במחרוזת.

30
00:01:54,330 --> 00:01:59,740
ואם דמות אותיות גדולה, ולאחר מכן
אנחנו הולכים להעביר אותו באמצעות זה

31
00:01:59,740 --> 00:02:01,860
נוסחה, שבו אנחנו יהיו
להגיע בשנייה.

32
00:02:01,860 --> 00:02:05,260
ואם זה היה באותיות קטנות, ולאחר מכן
אנו משמרות אותו באמצעות זה הוא

33
00:02:05,260 --> 00:02:07,290
נוסחה דומה מאוד.

34
00:02:07,290 --> 00:02:10,850
ואם זה לא היה באותיות גדולות ולא
אות קטנה - למשל, זה

35
00:02:10,850 --> 00:02:15,370
יכול להיות מספר או סמל - אז אנחנו
לא הולכים לעשות שום דבר אליו.

36
00:02:15,370 --> 00:02:18,220
>> אז, מה הן נוסחאות הללו?

37
00:02:18,220 --> 00:02:22,090
ובכן, איך אנחנו משמרות את האופי?

38
00:02:22,090 --> 00:02:27,250
אנחנו רוצים לטפל באופי
ככל שמספר 0.

39
00:02:27,250 --> 00:02:30,710
ואנחנו רוצים לטפל באופי
B כמספר 1, וכן הלאה.

40
00:02:30,710 --> 00:02:35,170
זה תווי האפס וראשון
של האלף וכן הלאה.

41
00:02:35,170 --> 00:02:42,900
>> אז הנה, הודעת מינוס אני אמור
לתת לנו את המקום המספרי של

42
00:02:42,900 --> 00:02:44,400
מכתב באלף הבית.

43
00:02:44,400 --> 00:02:48,080
אז אם הודעה הוא אני, זה
הוא הולך לתת לנו 0.

44
00:02:48,080 --> 00:02:52,880
עכשיו, אנחנו רוצים להוסיף לזה
מספר שהמשתמש רוצה

45
00:02:52,880 --> 00:02:54,840
לסובב את המכתב על ידי.

46
00:02:54,840 --> 00:03:03,280
לכן, אם הם נכנסו 3, אז אם הודעה
אני היה, זה ייתן לנו 0 ותוספת

47
00:03:03,280 --> 00:03:05,400
מפתח ייתן לנו 3.

48
00:03:05,400 --> 00:03:09,450
>> אז עכשיו, אנחנו שוקלים
מקום שלישי באלף הבית.

49
00:03:09,450 --> 00:03:12,810
אנחנו תראו למה אנחנו צריכים mod
על ידי אותיות num בשני.

50
00:03:12,810 --> 00:03:18,700
אבל לבסוף, ברצוננו להוסיף על
בסופו שוב כדי להעביר אותנו בחזרה אל תוך

51
00:03:18,700 --> 00:03:22,020
ערכי ASCII לתווים אלה
במקום מקומות המספריים ב

52
00:03:22,020 --> 00:03:24,260
האלפבית של דמויות אלה.

53
00:03:24,260 --> 00:03:26,580
>> אז, למה אנחנו mod על ידי אותיות num?

54
00:03:26,580 --> 00:03:29,960
זכור כי אנחנו רוצים לעטוף
מהסוף להאלפבית

55
00:03:29,960 --> 00:03:31,470
תחילתו של האלפבית.

56
00:03:31,470 --> 00:03:38,530
אז Z אם המשתמש נכנס, ולאחר מכן
חיסור מכי הוא הולך

57
00:03:38,530 --> 00:03:40,520
לתת לנו 25.

58
00:03:40,520 --> 00:03:44,800
ואם המפתח היה 3, ולאחר מכן
אנחנו הולכים יש לי 28.

59
00:03:44,800 --> 00:03:53,000
אבל Z צריך לעטוף ל-ABC, כך 28
מכתבי num mod, אשר מוגדרים חשיש

60
00:03:53,000 --> 00:04:01,890
כ26 צפויים, הוא הולך לתת לי
לנו 2, כאשר C הוא האות השנייה של

61
00:04:01,890 --> 00:04:05,880
האלפבית, אם אתה זוכר שהוא
מכתב האפס של האלפבית.

62
00:04:05,880 --> 00:04:09,210
>> אז בגלל זה אנחנו צריכים
mod על ידי אותיות num.

63
00:04:09,210 --> 00:04:13,540
עכשיו, אנחנו צריכים לעשות את אותו דבר מדויק
לאותיות קטנות, למעט

64
00:04:13,540 --> 00:04:17,240
זכור כי עם כשלנו עסק
אותיות קטנות, יש להם שונות

65
00:04:17,240 --> 00:04:18,579
ערכי ASCII.

66
00:04:18,579 --> 00:04:24,550
ולכן אנחנו צריכים להחסיר ולהוסיף על
להסיט אותו מהאותיות הקטנות

67
00:04:24,550 --> 00:04:30,020
ערכי ASCII ולאחר מכן חזרה ל
ערכי ASCII קטנות מקוריים.

68
00:04:30,020 --> 00:04:33,140
>> ולבסוף, שייתן לנו
ההודעה המוצפן שלנו.

69
00:04:33,140 --> 00:04:37,780
ובסופו של הדבר, אנחנו רק להדפיס
המסר הזה, וזהו זה.

70
00:04:37,780 --> 00:04:39,875
השם שלי הוא רוב, והיה קיסר.

71
00:04:39,875 --> 00:04:49,856