1
00:00:00,000 --> 00:00:01,940
[Powered by Google Translate] [ದರ್ಶನ - ಸಮಸ್ಯೆ ಸೆಟ್ 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
ಎಲ್ಲಾ ಸರಿ. ಹಲೋ, ಎಲ್ಲರೂ, ಮತ್ತು ದರ್ಶನ 2 ಸ್ವಾಗತ.

5
00:00:10,750 --> 00:00:14,330
ಮೊದಲ, ನಾನು pset 1 ಸ್ಥಾನ ನಿಮಗೆ ಅಭಿನಂದಿಸುತ್ತೇನೆ ಬಯಸುವ.

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
ನೀವು pset 1 ನೋಡಲು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ನೀವು "ಎಂದು 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
ಸರಿ, ಆದ್ದರಿಂದ ಉಪಕರಣ ಇಂದು ಮೊದಲ ಟೂಲ್ ವಾಸ್ತವವಾಗಿ APPLIANCE ಅಪ್ಡೇಟ್ ಏರಲಿದೆ.

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
ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಪರಿಹಾರ ನಿಮ್ಮ APPLIANCE ನವೀಕರಿಸಲು ಕೇವಲ ವಾಸ್ತವವಾಗಿ.

41
00:02:31,830 --> 00:02:36,730
ಆದ್ದರಿಂದ ನಿಮ್ಮ APPLIANCE sudo yum-ವೈ ಒಂದು ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿನ ಚಲಿಸಿದರೆ -

42
00:02:36,730 --> 00:02:40,040
ಆ ಹೌದು ಹೇಳುವ ಧ್ವಜ ಸ್, ಎಲ್ಲವನ್ನೂ ಅಪ್ಡೇಟ್ - ಅಪ್ಡೇಟ್,

43
00:02:40,040 --> 00:02:42,280
ಅಗತ್ಯ ಎಂದು ವೇಳೆ ನಂತರ ನಿಮ್ಮ APPLIANCE ನವೀಕರಿಸಿ.

44
00:02:42,280 --> 00:02:46,960
ನೀವು ಈಗಾಗಲೇ APPLIANCE ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಇದ್ದರೆ ಮತ್ತು ತೊಂದರೆ ಮಾಡುವುದಿಲ್ಲ.

45
00:02:46,960 --> 00:02:51,280
ನಂತರ ಇದು ಕೇವಲ ಯಾವುದೇ ಹೊಸ ಅಪ್ಡೇಟುಗಳು ಲಭ್ಯವಿದೆ ಹೇಳಲು ಮತ್ತು ನೀವು ಜೊತೆಯಲ್ಲಿ ಕೆಲಸ ಮುಂದುವರಿಸಬಹುದು.

46
00:02:51,280 --> 00:02:55,800
ಆದರೆ ನೀವು APPLIANCE ತೆರೆಯುವ ಪ್ರತಿ ಬಾರಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಉತ್ತಮ

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
ಆದ್ದರಿಂದ ನೀವು APPLIANCE ಇತ್ತೀಚಿನ ಆವೃತ್ತಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

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
ಇಲ್ಲಿ 1 ಮಿನಿ ASCII ಚಾರ್ಟ್ ಕೇವಲ ಒಂದು ಉದಾಹರಣೆ.

74
00:04:44,810 --> 00:04:48,460
ನಾನು ಹೇಳಿದಂತೆ, ಪ್ರತಿ ಪತ್ರ, ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ

75
00:04:48,460 --> 00:04:52,510
ಮತ್ತು ಆದ್ದರಿಂದ ನೀವೇ ಪರಿಚಿತರಾಗಿ. ಇದು HANDY ಬರುತ್ತವೆ.

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
ಝಡ್ ವರೆಗಿನ ಅವಶ್ಯಕವಾಗಿ, ಒಂದು ಹೊಂದಿಕೊಂಡಿದೆ, ಬಿ ಬಿ ಹೊಂದಿಕೊಂಡಿದೆ, ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ

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
ನಂತರ, ಒ ಮೂಲಕ ಇನ್ಪುಟ್ ಡಿ ಎಂದು 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
ನಮ್ಮ ಸಿ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಇಂಟ್ ಮುಖ್ಯ (ಶೂನ್ಯ) ಹೊಂದಿತ್ತು. ಆದ್ದರಿಂದ ಮೊದಲು

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
ನಾವು 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
ನಂತರ ನೀವು ಟೈಪ್ ಇಂಟ್ ರಚನೆಯ ಎಂದು ಹೊಸ ವೇರಿಯಬಲ್ ರಚಿಸಿದರು.

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
1 - ಇದು 4.

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
2.4 ಗೆ ಅಂಚೆಪೆಟ್ಟಿಗೆ ಸೂಚ್ಯಂಕ 1 ಸೆಟ್, ಇತ್ಯಾದಿ

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
ಅವರು ಹೇಳುತ್ತಾರೆ. / ನಿನ್ನ ಡೇವಿಡ್ Malan,

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
ಇದು ಖಾಲಿ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಟ್ಟ 3 ವಿಭಿನ್ನ ಪದಗಳನ್ನು ನೋಡುತ್ತಾನೆ ಏಕೆಂದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ Argc 3 ಆಗಿರುತ್ತದೆ.

150
00:10:14,370 --> 00:10:18,850
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ರಚನೆಯ ಮೊದಲ ಸೂಚ್ಯಂಕ ಎಂದು. / ಹಲೋ,

151
00:10:18,850 --> 00:10:21,770
ಮುಂದಿನ ಒಂದು ಡೇವಿಡ್, ಮುಂದಿನ ಒಂದು Malan.

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
. ಸಿ ಕಡತಗಳನ್ನು ತೆರೆಯಲು ಕೆಲವೊಮ್ಮೆ ಈಮಾಕ್ಸ್ GenericName ಹೊಂದಿದೆ.

158
00:10:49,450 --> 00:10:54,660
ಆದರೆ ನಾವು ಜಿಎಡಿಟ್ Name ವ್ಯವಹರಿಸಲು ಬಯಸುವ, ನೀವು ಏನು ಮಾಡಬಹುದು ನಿಮ್ಮ ಸಿ ಫೈಲ್ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಬಹುದು ಆದ್ದರಿಂದ

159
00:10:54,660 --> 00:11:04,580
ಈತಂತ್ರಾಂಶದಿಂದತೆರೆ, ಪ್ರಾಪರ್ಟೀಸ್ ಗೆ ಹೋಗಿ, ನಂತರ ಡೀಫಾಲ್ಟ್ ಆಗಿ ಹೊಂದಿಸಿ ಜಿಎಡಿಟ್ Name, ಆಯ್ಕೆ

160
00:11:04,580 --> 00:11:13,020
ಈಗ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಜಿಎಡಿಟ್ Name ಬದಲಿಗೆ ಈಮಾಕ್ಸ್ GenericName ರಲ್ಲಿ ತೆರೆಯಬೇಕು.

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
ನೀವು ಬಹುಶಃ ನಿಮ್ಮ pset 1 ಬಳಸಿದ ಏನೋ?

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
ನಾವು ಇಂಟ್ ನಾನು = 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
ಸಿ ಖಂಡಿತವಾಗಿಯೂ ನೀವು ಕೂಗು ಏಕೆಂದರೆ.

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
ನಾವು ಶೂನ್ಯ ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ, 0 ಆರಂಭವಾಗುವುದು ಏಕೆಂದರೆ ರಚನೆಯ ಸೂಚ್ಯಂಕ 4 ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ.

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
ಮುಖ್ಯ ಅದನ್ನು, ಇಂಟ್ ಮುಖ್ಯ ಹೇಳುತ್ತದೆ ಒಂದು ಫಂಕ್ಷನ್ ನ

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
[ವಿದ್ಯಾರ್ಥಿ] ಕೇವಲ 1 argc ವಿರುದ್ಧವಾಗಿ ನೀವೇಕೆ 2 ಬೇಕು? 1 ಸಂಖ್ಯೆ ಖಂಡಿತವಾಗಿಯೂ ಇಲ್ಲ.

242
00:17:27,569 --> 00:17:32,200
ರೈಟ್. ನಾವು argc 2 ಅಗತ್ಯವಿದೆ ಕಾರಣವಾಗಿದೆ ಬದಲಿಗೆ 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
ಆದ್ದರಿಂದ ಆರಂಭದಲ್ಲಿ ನಾವು ಒಂದು ಹ್ಯಾಶ್ ಟ್ಯಾಗ್ ಗುಣಮಟ್ಟದ I / O,. H, ಏನೋ ಆರಂಭವಾಗಬೇಕು.

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
ನಾನು ಕೈಯಿಂದ ಕಾರ್ಯ ಚರ್ಚಿಸುವ ದರ್ಶನ 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 ನಲ್ಲಿ ಪಠ್ಯ ಒಂದು ಬಂಡವಾಳ ಟಿ ಎಂದು, ಸೂಚ್ಯಂಕ 1 ಗಂ, ಇತ್ಯಾದಿ ಎಂದು

284
00:20:17,530 --> 00:20:23,970
ತದನಂತರ ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ args.c ರಲ್ಲಿ argc ಉದಾಹರಣೆಯಲ್ಲಿ,

285
00:20:23,970 --> 00:20:27,090
ನಾವು ಒಂದು ರಚನೆಯ ಮೇಲೆ ತಿರುಗಿ ಎಂಬ ಕಂಡಿತು

286
00:20:27,090 --> 00:20:32,440
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು ಉದ್ದವನ್ನು ಕಡಿಮೆ ತನಕ ನಾನು = 0 ಅನ್ನು ಮರಳಿ ಬಂತು.

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
ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಹಾದು, ಮತ್ತು ನಂತರ ನೀವು ನಿಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಇಂಟ್ ಹಿಂತಿರುಗುವುದು.

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
ಆದ್ದರಿಂದ ಲೂಪ್ ಫಾರ್ ಆರಂಭಿಸೋಣ. ಇಂಟ್ ನಾನು = 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
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಸ್ಟ್ರಿಂಗ್ ರು ಮಾತಾಡುತ್ತಿದ್ದೀರಿ.

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
ಒಂದು ಇಂಟ್ ನಿಮಗೆ% d ಅನ್ನು ಬಳಸಬಹುದು.

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
ಮತ್ತು ಆ ಪಾತ್ರ ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ರು ರಲ್ಲಿ ಇತ್ ಅಕ್ಷರದ ಏರಲಿದೆ.

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
ಮೊದಲು, ನಾವು ಒಂದು ಇಂಟ್ ಬಂದೆವು?

333
00:24:01,610 --> 00:24:08,040
ನಾವು GetInt, ಬಲ ಹೇಳಿದರು? ಆದರೆ ಈ ಇಂಟ್ ಅಲ್ಲ, ಆದ್ದರಿಂದ 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
ನೀವು 73 + 6 ASCII ಮೌಲ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಯಾವುದೇ ಅಕ್ಷರದ ಅವುಗಳನ್ನು ಮರಳಲು ಬಯಸುವ.

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
Lowercases ಸಣ್ಣ ಮಾಹಿತಿ ಉಳಿಯಲು ಮಾಡಬೇಕು.

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
ಆದ್ದರಿಂದ ನಾನು + 6 ಒ ಏಕೆಂದರೆ ನಾನು ಓ ಹೋಗುತ್ತದೆ ತಿಳಿದಿದೆ

377
00:27:14,550 --> 00:27:18,740
ಆದರೆ ನಾವು ಒ ಒಂದು ಬಂಡವಾಳ ಒ ಏರಲಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ

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
ಆದ್ದರಿಂದ ಬಂಡವಾಳ ಸಿ 67 ಸಂಬಂಧಿಸಿದೆ. ಸಣ್ಣ F 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
ಮತ್ತು ಇಲ್ಲಿ ನಾನು ಹೇಳುವ ನಾನು - ಈ ಭಾಗವು we'll ಒಪ್ಪಂದದ ನಂತರ -

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 ನಮಗೆ 118 ರ ASCII ಮೌಲ್ಯವನ್ನು ಅನುರೂಪವಾಗಿರುವ V, ನೀಡಲು ಹೋಗುತ್ತದೆ ಹೆಚ್ಚಾಗಿದೆ.

430
00:31:39,280 --> 00:31:43,880
ಆದ್ದರಿಂದ ಇದು ರೀತಿಯ ಅರ್ಥದಲ್ಲಿ ಮಾಡುತ್ತದೆ -

431
00:31:43,880 --> 00:31:51,250
ವಾಸ್ತವವಾಗಿ, ನಾನು, ನೀವು ಕೇಳಬಹುದು ನೀವು R + 4 118 ವೇಳೆ R ನ ASCII ಮೌಲ್ಯವನ್ನು ಏನು ಆಲೋಚಿಸುತ್ತೀರಿ ಏನು?

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
ನೀವು ಜೆಡ್ ತಲುಪಲು ಮತ್ತು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಬಯಸಿದಾಗ,

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 ಉಳಿದ ನೀಡುವ X ಪ್ರಮಾಣ ವೈ, ಹೊಂದಿರುವಾಗ.

453
00:33:26,920 --> 00:33:30,930
ಇಲ್ಲಿ ಕೆಲವು ಉದಾಹರಣೆಗಳಾಗಿವೆ. ನಾವು 27% 15 ಹೊಂದಿರುತ್ತವೆ.

454
00:33:30,930 --> 00:33:36,200
ಮೂಲಭೂತವಾಗಿ, ನೀವು ಋಣಾತ್ಮಕ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಬಾರಿ 27 ರಿಂದ 15 ಕಳೆದಾಗ

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 ಹೇಳಿದರು, ಆದರೆ ಕೇವಲ 3 ಗುಂಪುಗಳ ಬಯಸುವ ನಾವು ವಾಸ್ತವವಾಗಿ 1 ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ.

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 ಅಳತೆಯ 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 ಅಳತೆಯ 3 2 ಹೇಳುತ್ತಾರೆ.

475
00:34:53,760 --> 00:34:59,100
ನಾನು ಉಳಿದ ಎಷ್ಟು 3 ಗುಂಪುಗಳ ನೋಡಲು ಬಯಸುವ, ನಂತರ ಆದೇಶ ಐ am

476
00:34:59,100 --> 00:35:02,860
ಆದ್ದರಿಂದ ನಾವು, ಇಡೀ ಕೊಠಡಿ ಉದ್ದಕ್ಕೂ ಮುಂದುವರೆದರೆ

477
00:35:02,860 --> 00:35:07,760
ನಂತರ ನಾವು ಯಾವಾಗಲೂ ನಿಜವಾಗಿ ನಾವೇ ಗೆ ಮಾಡ್ ಕಾರ್ಯ ಅನ್ವಯಿಸುವ ನೀವು ನೋಡುವ

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 ಅಳತೆಯ 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 ಅಳತೆಯ 3 ವಾಸ್ತವವಾಗಿ 0 ಆದರೆ ಆಕೆ 3 ಹೇಳಿದರು.

492
00:36:07,720 --> 00:36:14,900
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ಒಂದು ಒಳ ಕ್ಯಾಚ್ ಮುಂತಾದ ರೀತಿಯ ಇಲ್ಲಿದೆ,

493
00:36:14,900 --> 00:36:17,620
ಮಾಡ್ ನಂತರ 0 ಆಗಿದ್ದರೆ ಸರಿ ನಾನು 3 ನೇ ವ್ಯಕ್ತಿ ವೃಂದದಲ್ಲಿರುತ್ತೇನೆ.

494
00:36:17,620 --> 00:36:22,740
ಆದರೆ ನಾವು 0 ನಂತರ ಯಾವ ವ್ಯವಹರಿಸಲು ಬಯಸಬಹುದು ಹೇಗೆ ರೀತಿಯ ಆಗಿ ಪಡೆಯುತ್ತೀರಿ.

495
00:36:22,740 --> 00:36:32,750
ಈಗ ನಾವು ಹೇಗಾದರೂ ಬಲ ಪತ್ರದ ಜೆಡ್ ಮಾಪನದ ಒಂದು ರೀತಿಯಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ.

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
ಆದ್ದರಿಂದ ಈ ಹೇಳುತ್ತದೆ ಸೈಫರ್ಟೆಕ್ಸ್ಟ್ ಇತ್ ಪಾತ್ರ

504
00:36:58,300 --> 00:37:02,500
ಸರಳಪಠ್ಯ ಆಫ್ ಇತ್ ಪಾತ್ರವನ್ನು ಹೋಲುತ್ತದೆ ಹೋಗುತ್ತದೆ.

505
00:37:02,500 --> 00:37:08,130
ನಾವು ಯಾವಾಗಲೂ ಅಪ್ ಈ ವಿಷಯಗಳನ್ನು ಆವರಿಸಿರುವ ಬೇಕಿರುವ ಏಕೆಂದರೆ ಅರ್ಥವಿಲ್ಲ.

506
00:37:08,130 --> 00:37:13,480
ಆದ್ದರಿಂದ ನಮ್ಮ ಪ್ರಮುಖ ಇದು ಸೈಫರ್ಟೆಕ್ಸ್ಟ್ ಪ್ಲಸ್ K, ನ ಇತ್ ಪಾತ್ರ ಎಂದು ವಿಶೇಷವೇನು -

507
00:37:13,480 --> 00:37:17,230
ಆ ಅರ್ಥದಲ್ಲಿ ಮಾಡುತ್ತದೆ - ಮತ್ತು ನಾವು ಈ ಮೋಡ್ 26 ಹೊಂದಿರುತ್ತವೆ.

508
00:37:17,230 --> 00:37:19,860
ನಾವು ಜೆಡ್ ಬಂದಾಗ ಮತ್ತೆ ನೆನಪಿಡಿ

509
00:37:19,860 --> 00:37:24,190
ನಾವು ಅಕ್ಷರ ಬರಲು ಇಷ್ಟಪಡುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಮಾಡ್ ಬಯಸಿದರು

510
00:37:24,190 --> 00:37:26,540
ವರ್ಣಮಾಲೆಯ ಸುತ್ತ ಸುತ್ತು ಮತ್ತು ರೀತಿಯ.

511
00:37:26,540 --> 00:37:33,430
ಜೆಡ್ ನಂತರ ನೀವು ಹೋಗುತ್ತಿದ್ದೆ ಬೌ, ನೀವು ಸರಿಯಾದ ಸಂಖ್ಯೆಯ ಸಿ, ಡಿ, ತನಕ.

512
00:37:33,430 --> 00:37:44,690
ನಾವು ತಿಳಿದಿರುವ ಜೆಡ್, ಜೆಡ್ ಒಂದು, ಬಿ, ಸಿ, ಡಿ, ಇ, ಎಫ್ ಬರುತ್ತದೆ ನಂತರ ಏಕೆಂದರೆ + 6, ನಮಗೆ F ನೀಡಿ ಎಂದು.

513
00:37:44,690 --> 00:37:52,530
ಆದ್ದರಿಂದ ನಾವು ಜೆಡ್ + 6 ನಮಗೆ F ನೀಡಲು ಹೋಗಿ ಎಂದು ತಿಳಿದಿರುವುದಿಲ್ಲ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಅವಕಾಶ.

514
00:37:52,530 --> 00:38:03,530
ASCII ಮೌಲ್ಯಗಳನ್ನು, z 122 ಮತ್ತು ಎಫ್ 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
ನಾವು ಈ ಸೂತ್ರ, ವಾಸ್ತವವಾಗಿ 24 ನೀಡುತ್ತದೆ ಎಂದು ('Z' + 6)% 26, ಅರ್ಜಿ ಹಾಗಿದ್ದಲ್ಲಿ

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 ಪತ್ರ ಮತ್ತು ಎಫ್ 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 ನೀವು 31 ನೀಡುತ್ತದೆ, 25 + 6 ನಿರೂಪಿಸಲಾಗಿದೆ ಹೊಂದಿರುತ್ತವೆ.

528
00:39:11,710 --> 00:39:15,790
ಮತ್ತು 31 ಅಳತೆಯ 26 ಒಂದು ಶೇಷವಾಗಿ ನೀವು 5 ನೀಡುತ್ತದೆ.

529
00:39:15,790 --> 00:39:20,500
ನಾವು ಎಫ್ ವರ್ಣಮಾಲೆಯ 5 ನೇ ಅಕ್ಷರ ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ ಎಂದು ಪರಿಪೂರ್ಣವಾಗಿದ್ದಾರೆ.

530
00:39:20,500 --> 00:39:26,400
ಆದರೆ ಇನ್ನೂ ಬಲ, ಎಫ್ ಅಲ್ಲ? ಇದು ಇನ್ನೂ 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
ನಾವು ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ನಮ್ಮ ಪ್ರಮುಖ ಪಡೆದ ನಾವು, ನಾವು, ಸರಳಪಠ್ಯ ನೆತ್ತಿಗೇರಿದೆ ನೀವು

540
00:40:15,690 --> 00:40:17,520
ನಾವು enciphered ಮಾಡಿದ್ದೀರಿ.

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
ಬಹುಶಃ 25 ಮೂಲಕ 0 ವರ್ಣಮಾಲೆಯ ಸೂಚಿಗೆ ತೋರಿಸುವ ನಿಮ್ಮ ಸ್ವಂತ ASCII ಟೇಬಲ್ ಹುಡುಕಲು ಅಥವಾ ಮಾಡಲು

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
ನಾವು ಟಿ, ಒ ಅದಕ್ಕೆ ವರ್ಗಾಯಿಸಲ್ಪಡುತ್ತವೆ ಹೋಗುವ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ

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
[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ ಓ ಅದೇ ಬದಲಾವಣೇಯಾಗಿ ಹೋಗುವ ಇದೆ -

602
00:44:52,020 --> 00:44:56,260
ಆದ್ದರಿಂದ ಓ ವರ್ಣಮಾಲೆಯ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಗೆ ಹೊಂದಿಕೊಂಡಿರುತ್ತದೆ.

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, ಮುಂದಿನ ಒಂದು ನಮ್ಮ ಸ್ಥಾನದ ವಿಷಯದಲ್ಲಿ ನಾವು ಒ ಬಳಸಲಾಗುತ್ತದೆ.

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 ಮತ್ತು H ಅನುವಾದ ಯಾವ ನಾನು ಮತ್ತು ರು ಹೊಂದಿರುತ್ತವೆ.

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
ಆದ್ದರಿಂದ, ನೀವು ವಾಸ್ತವವಾಗಿ ಪೂರ್ವನಿರ್ಧರಿತ ಹೇಳುವ, ಓ ಇಲ್ಲಿ ಹೋಗುವುದು ಅಲ್ಲ, H ಇಲ್ಲಿ ಹೋಗುವುದು,

622
00:46:33,710 --> 00:46:39,200
ಒಂದು ಇಲ್ಲಿ ಹೋಗುವುದು, ನಾನು ಒ, 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
ನಾವು ಒ ಸ್ಥಾನದಲ್ಲಿದ್ದೀರೋ ಹೀಗೆ ಹೇಳುತ್ತಿಲ್ಲ.

631
00:47:09,120 --> 00:47:19,310
ನಾವು ಮುಂದಿನ ಪಾತ್ರ ಸರಳಪಠ್ಯ ಆಫ್ I ಸೂಚ್ಯಂಕ, ಉದಾಹರಣೆಗೆ, ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಗಮನಿಸಿ.

632
00:47:19,310 --> 00:47:31,630
ಮತ್ತೊಂದು ಪತ್ರ ತಲುಪುವವರೆಗೆ ನಾವು, J, ನಮ್ಮ ಮುಖ್ಯಪದಕ್ಕೆ ಸೂಚ್ಯಂಕ ಮುನ್ನಡೆ ಇಲ್ಲ.

633
00:47:31,630 --> 00:47:36,230
ಮತ್ತೆ, ನೀವು ಕೀವರ್ಡ್ ಆರಂಭಕ್ಕೆ ನೀವು wraparound ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುವ

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
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕೀವರ್ಡ್ ಆರಂಭಕ್ಕೆ wraparound ಸಾಮರ್ಥ್ಯವನ್ನು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಹುಡುಕಲು ಬಯಸುವ

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 ರಲ್ಲಿ ಸೂಚ್ಯಂಕ ಮೇಲೆ ಕಟ್ಟಲು ಯಾವಾಗಲೂ ಬಯಸಿದಾಗ ಇಲ್ಲಿ HANDY ಬರುತ್ತವೆ.

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
ಅವರು ತಮ್ಮ ನಂಬರ್ 1 ಇದು 4 ಅಳತೆಯ 3, ಆಗಿತ್ತು.

645
00:48:30,610 --> 00:48:32,880
ಆದ್ದರಿಂದ ಆ ರೀತಿಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ತಿಳಿಯುತ್ತಾರೆ.

646
00:48:34,770 --> 00:48:42,740
ನೀವು ನಂತರ KJ CI ತದನಂತರ ಪೈ ಆದರೆ ಎಲ್ಲೆಲ್ಲಿ, ಸೂತ್ರದಲ್ಲಿ ನೋಡಿದ

647
00:48:42,740 --> 00:48:44,700
ನೀವು ಆ ಟ್ರ್ಯಾಕ್ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಬಯಸುತ್ತೇನೆ.

648
00:48:44,700 --> 00:48:47,580
ನೀವು ಕರೆಯ ಮಾಡಬೇಕಿಲ್ಲ, ನೀವು, ಅದು ಜೆ ಕರೆ ಅಗತ್ಯವಿಲ್ಲ

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
[ಮೀಡಿಯಾ ಆಫ್ಲೈನ್ ಪರಿಚಯ]