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

2
00:00:11,980 --> 00:00:16,980
>> రాబ్: హాయ్, నేను రాబ్ ఉన్నాను, మరియు యొక్క అర్థమును తెలియజేయండి
విజెనెరే కార్యక్రమం.

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
మా Encrypting వంటి ఉపయోగించి కావలసిన
స్ట్రింగ్, లేదా వారు

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
ఇప్పుడు, మేము, argc 2 అని ఊహించుకొని
కార్యక్రమం మిగిలిన కొనసాగుతుంది.

12
00:00:44,570 --> 00:00:47,890
>> మేము [1] argv పేరు అలియాస్

13
00:00:47,890 --> 00:00:49,750
వేరియబుల్ కీవర్డ్ లోకి.

14
00:00:49,750 --> 00:00:51,860
మేము లేదు కాబట్టి
[1] పేరు argv ఉపయోగించడానికి

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
కీవర్డ్ చాలా NICER పేరు.

18
00:00:57,830 --> 00:01:01,982
మరియు మేము వెంటనే పొడవు పట్టుకోడానికి ఉంటుంది
ఇక్కడే మా కీవర్డ్.

19
00:01:01,982 --> 00:01:07,460
>> OK, కాబట్టి ఇప్పుడు మేము ఆ తనిఖీ మీరు
మా కీవర్డ్ నిజానికి చెల్లుతుంది.

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
>> కొనసాగిస్తూ, మేము ఇక్కడ ఈ వేరియబుల్ చూడండి,
పూర్ణాంకానికి nun_letters_seen.

33
00:01:58,690 --> 00:02:01,300
మేము అవసరం ఎందుకు మేము చూస్తారు
రెండవ ఆ.

34
00:02:01,300 --> 00:02:07,320
కాని లూప్ ఈ iterate అన్నారు
నేను అప్ 0 అన్ని మార్గం సమానం నుండి

35
00:02:07,320 --> 00:02:10,940
మేము iterating అంటే, n సమానం
అన్ని సాధ్యం పైగా

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
ఇప్పుడు, naively, మేము అర్థం భావిస్తున్న
మేము మొదటి పాత్ర గుప్తీకరించడానికి మీరు

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 ద్వారా h గుప్తీకరించడానికి మీరు

54
00:03:26,590 --> 00:03:32,680
, 1 ద్వారా ఒక, ఇ సంబంధిత
l 2 ద్వారా, 0 ద్వారా l, 1 ద్వారా o.

55
00:03:32,680 --> 00:03:41,050
మేము ఎన్క్రిప్టెడ్, స్పేస్ వెళ్ళకండి
2 ద్వారా w, 0, 1, 2, 0 ద్వారా o.

56
00:03:41,050 --> 00:03:45,250
మేము దిగింది చేసింది అయితే, గమనించవచ్చు
స్పేస్, అప్పుడు మేము ఎన్క్రిప్టెడ్ ఉండేది

57
00:03:45,250 --> 00:03:51,240
0 ద్వారా w మరియు తో ముగించారు
తప్పు స్ట్రింగ్.

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
చిహ్నాలు, స్పేస్ మరియు సంఖ్యలను అప్పుడు మేము
కేవలం నేను ఏమి వంటి వేరియబుల్ ఉపయోగించవచ్చు

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 mod keyword_length, కాబట్టి

65
00:04:32,240 --> 00:04:34,570
ఎందుకు మేము mod చేయాలి
కీవర్డ్ పొడవు ద్వారా?

66
00:04:34,570 --> 00:04:36,630
>> Well, హలో ప్రపంచ ఒక మంచి ఉదాహరణ.

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
>> కాబట్టి, ఈ ఒక పెద్ద అక్షరం ఉంటే
తర్వాత మేము ద్వారా Int ప్రధాన

71
00:04:57,280 --> 00:05:01,450
వర్ణమాలలో లేఖ యొక్క స్థానం,
మేము చాలా పొందుటకు ఇది

72
00:05:01,450 --> 00:05:06,730
రాజధాని A. తీసివేయడం మరియు
అదేవిధంగా, చిన్న అక్షరాలను కోసం, మేము

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 మేము తిరిగి ఒక, బి, సి వెళ్లి,.

80
00:05:43,170 --> 00:05:49,070
, చివరకు, రాజధాని A. తిరిగి జోడించండి కాబట్టి
మేము [తిరిగి మారవచ్చు? 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
ఈ ఫైళ్ళను, చిహ్నాలు skip ఎలా ఉంది, మరియు
మా కీ పదబంధం, నుండి సంఖ్యలు

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
నేను సందేశాన్ని ముద్రించడానికి.

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
మరియు ఈ విజెనెరే ఉంది.

95
00:06:31,020 --> 00:06:32,850
>> [MUSIC ప్లే]

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