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

2
00:00:11,980 --> 00:00:16,980
>> ರಾಬ್: ಹಾಯ್, ನಾನು ರಾಬ್ ಮನುಷ್ಯ, ಮತ್ತು ನ ಅರ್ಥ ಅವಕಾಶ
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
ಈಗ, ನಾವು, argc, 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
ನಾವು ಹೊಂದಿಲ್ಲ ಎಂದು ಆದ್ದರಿಂದ
[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
ಕೀವರ್ಡ್ ಬಹಳ ಒಳ್ಳೆಯದೆಂದು ಹೆಸರು.

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
ಕೇವಲ ಒಂದು ಮೂಲಕ ಹೊಂದಿರಬೇಕು
ನಂತರ ಝಡ್ ಮತ್ತು ಮರಳಲು.

24
00:01:20,170 --> 00:01:24,370
ಆದ್ದರಿಂದ ಈ ಲೂಪ್ iterates ಮೇಲೆ ಎಲ್ಲಾ
ನಮ್ಮ ಕೀವರ್ಡ್ ಪಾತ್ರಗಳು, ಪರೀಕ್ಷಿಸುವ

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
ಆದರೆ ಲೂಪ್ ಈ ಮರಳಿ ಹೋಗುವ ಇದೆ
ನಾನು ಅಪ್ 0 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಸಮನಾಗಿರುತ್ತದೆ ನಿಂದ

35
00:02:07,320 --> 00:02:10,940
ನಾವು 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
>> ಊಹಿಸುತ್ತವೆ ಅವಕಾಶ ಪ್ರಮುಖ ನುಡಿಗಟ್ಟು
ಪ್ರವೇಶಿಸಿತು ಬಳಕೆದಾರ ಎಬಿಸಿ ಆಗಿತ್ತು.

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 ಒಂದು, ಇ ಅನುಗುಣವಾದ
ಎಲ್ 2, 0 ಎಲ್, 1 ಮೂಲಕ ಒ.

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 ಮಾಡ್ keyword_length, ಆದ್ದರಿಂದ

65
00:04:32,240 --> 00:04:34,570
ಏಕೆ ನಾವು ಮಾಡ್ ಬೇಕು
ಕೀವರ್ಡ್ ಉದ್ದ?

66
00:04:34,570 --> 00:04:36,630
>> ಸರಿ, ಹಲೋ ವಿಶ್ವದ ಒಂದು ಉತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ.

67
00:04:36,630 --> 00:04:42,310
ಕೀವರ್ಡ್ ಎಬಿಸಿ ಮಾಡಿದರೆ, ನಂತರ ನಾವು ಅಗತ್ಯವಿದೆ
ನಿರಂತರವಾಗಿ ಬೌ ಒಂದು ಆಗಿನ ಗೂಢಲಿಪೀಕರಿಸಲು

68
00:04:42,310 --> 00:04:45,740
ನಂತರ ಸಿ, ನಂತರ ಸುಮಾರು ಮತ್ತೆ ಕಟ್ಟಲು
ಎ, ಬಿ, ಸಿ, ಎ, ಬಿ, ಸಿ.

69
00:04:45,740 --> 00:04:50,110
ನಾವು ಕೀವರ್ಡ್ ಉದ್ದ ಮಾಡ್ ಅಗತ್ಯವಿದೆ
ಸುತ್ತ ಮತ್ತೆ ಕಟ್ಟಲು ಸಲುವಾಗಿ.

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 ನ ನಾವು ಮತ್ತೆ ಎ, ಬಿ, ಸಿ ಹೋಗಿ, ಮತ್ತು.

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
ನಾನು ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

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