1
00:00:00,000 --> 00:00:03,944
>> [ಸಂಗೀತ]

2
00:00:03,944 --> 00:00:10,732

3
00:00:10,732 --> 00:00:11,690
DAVID MALAN: ಸರಿ.

4
00:00:11,690 --> 00:00:14,674
ಈ CS50 ಆಗಿದೆ, ಮತ್ತು ಈ
ವಾರ 2 ಅಂತ್ಯ.

5
00:00:14,674 --> 00:00:16,840
ನಾನು ಸಾಧ್ಯವಿಲ್ಲ ಕ್ಷಮಿಸಿ
ಎಲ್ಲಾ ಇಂದು ನಿಮ್ಮೊಂದಿಗೆ,

6
00:00:16,840 --> 00:00:18,300
ಆದರೆ ನೀವು ಉತ್ತಮ ಕೈಯಲ್ಲಿ ಆರ್.

7
00:00:18,300 --> 00:00:21,710
ನನಗೆ ಪರಿಚಯಿಸಲು ಅವಕಾಶ
CS50 ಆದ ರಾಬ್ ಬೌಡೆನ್.

8
00:00:21,710 --> 00:00:29,106

9
00:00:29,106 --> 00:00:31,730
ರಾಬ್ ಬೌಡೆನ್: ಮತ್ತು ಸಹಜವಾಗಿ, ನಂತರ
ನಾವು ವಾಸ್ತವವಾಗಿ ಮೋಜು ಮಾಡಲು ಹೊಂದಿವೆ

10
00:00:31,730 --> 00:00:36,820
ಅವರು ನಮಗೆ ಒಂದು ಲಂಬ ಕಳುಹಿಸಿದ
ವೀಡಿಯೊ ಮತ್ತು ಈ ತೋರಿಸಲು.

11
00:00:36,820 --> 00:00:38,320
>> [ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

12
00:00:38,320 --> 00:00:39,820
>> [ಸಂಗೀತ]

13
00:00:39,820 --> 00:00:42,350
>> [ಹಾದಿಯನ್ನೇ]

14
00:00:42,350 --> 00:00:44,730
>> -ಈ ವೀಡಿಯೊ ಮಾಡಲಿಲ್ಲ
ಈ ರೀತಿಯಲ್ಲಿ ನೋಡಲು ಹೊಂದಿವೆ.

15
00:00:44,730 --> 00:00:46,570
ಇದು ತಡೆಯುತ್ತಿದ್ದ ಮಾಡಲಾಗಿದೆ.

16
00:00:46,570 --> 00:00:49,070
ಯಾವುದೇ ಲಂಬ ವೀಡಿಯೊಗಳನ್ನು ಸೇ.

17
00:00:49,070 --> 00:00:53,310
>> -Vertical ವೀಡಿಯೊಗಳನ್ನು ನೀವು ಸಂಭವಿಸಿ
ನಿಮ್ಮ ಕ್ಯಾಮೆರಾ ತಪ್ಪು ದಾರಿ ಹಿಡಿಯಲು.

18
00:00:53,310 --> 00:00:55,880
ನಿಮ್ಮ ವೀಡಿಯೊ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ
ಅಪ್ ಅಮೇಧ್ಯ ಕಾಣುವ.

19
00:00:55,880 --> 00:00:57,650
>> - [ಗುರುಗುಟ್ಟುತ್ತಾ]

20
00:00:57,650 --> 00:01:02,240
>> ಗೀಳು ಹೆಚ್ಚು ಹೆಚ್ಚು ಜನರು-ಅಲ್ಲಿ ಇವೆ
ಪ್ರತಿ ದಿನ ಲಂಬ ವೀಡಿಯೊಗಳು ಮಾಡುವ.

21
00:01:02,240 --> 00:01:06,240
ಬಿರುಕು ಅಥವಾ ಏನೂ ಅಲ್ಲ,
ಆದರೆ ಇದು ಇನ್ನೂ ನಿಜವಾಗಿಯೂ ಹಾನಿಕಾರಕ.

22
00:01:06,240 --> 00:01:10,410
ಎರಡು ಬಗೆಯ
ವಿವಿಎಸ್ ನರಳುತ್ತಿರುವ ಜನರಿಗೆ.

23
00:01:10,410 --> 00:01:14,160
ಮೊದಲ ಗುಂಪು ಪರಿಗಣಿಸುತ್ತದೆ
ವೀಡಿಯೊಗಳನ್ನು ಅವರು ಚಿತ್ರಗಳನ್ನು ರೀತಿಯ ಶೂಟ್.

24
00:01:14,160 --> 00:01:15,850
ಅವರು ಯಾವುದೇ ಹಾನಿ ಅರ್ಥವಲ್ಲ.

25
00:01:15,850 --> 00:01:19,180
ಅವರು ಕೇವಲ ಅರ್ಥವಾಗದ
ನೀವು ಒಂದು ಚಿತ್ರವನ್ನು ಮಾಡಬಹುದು ಆದರೆ,

26
00:01:19,180 --> 00:01:20,880
ನೀವು ನಿಜವಾಗಿಯೂ ವೀಡಿಯೊ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.

27
00:01:20,880 --> 00:01:21,880
>> [ಕುಸಿತ]

28
00:01:21,880 --> 00:01:23,460
>> - [ಮಂಕಿ ಶಬ್ದಗಳನ್ನು]

29
00:01:23,460 --> 00:01:27,540
>> ರೆಪ್ಪೆ ಇತರ ಗುಂಪಿನ ಜನರು
ಒಬ್ಬ [ಬ್ಲೀಪ್] ನೀಡುವುದಿಲ್ಲ.

30
00:01:27,540 --> 00:01:31,090
>> -Vertical ವೀಡಿಯೊ ಸಿಂಡ್ರೋಮ್ ಅಪಾಯಕಾರಿ.

31
00:01:31,090 --> 00:01:34,120
ಚಲನಚಿತ್ರಗಳು ಹೊಂದಿವೆ
ಯಾವಾಗಲೂ ಅಡ್ಡ ಎಂದು.

32
00:01:34,120 --> 00:01:35,990
ಟೆಲಿವಿಷನ್ ಸಮತಲ.

33
00:01:35,990 --> 00:01:38,380
ಕಂಪ್ಯೂಟರ್ ಪರದೆಯ ಸಮತಲ.

34
00:01:38,380 --> 00:01:41,580
ಜನರ ಕಣ್ಣುಗಳು ಸಮತಲ.

35
00:01:41,580 --> 00:01:45,170
ನಾವು ರಚಿಸಲ್ಪಟ್ಟಿಲ್ಲ
ಲಂಬ ವೀಡಿಯೊಗಳನ್ನು ವೀಕ್ಷಿಸಲು.

36
00:01:45,170 --> 00:01:47,600
>> -ನಾನು ಲಂಬ ವೀಡಿಯೊಗಳನ್ನು ಪ್ರೀತಿ.

37
00:01:47,600 --> 00:01:50,410
>> -Nobody ನೀವು ಕಾಳಜಿ.

38
00:01:50,410 --> 00:01:53,340
>> ವೇಳೆ- ಈ ಸಮಸ್ಯೆಯೊಂದರ
ಪರಿಶೀಲಿಸದೆ, ನೀವು ತುಂಬಾ ಬಿಟ್ಟು

39
00:01:53,340 --> 00:01:57,650
ನಾಲ್ಕು ವೀಡಿಯೊಗಳನ್ನು ತೋರಿಸುವ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ
ಏಕಕಾಲದಲ್ಲಿ ಕೇವಲ ಬ್ಯಾಂಡ್ವಿಡ್ತ್ ಉಳಿಸಲು.

40
00:01:57,650 --> 00:02:02,400
>> -Letterboxed ಲಂಬ ವೀಡಿಯೊಗಳನ್ನು ಎಂದು
ಒಂದು ಅಂಚೆ ಚೀಟಿಯ ಗಾತ್ರ ಎಂದು.

41
00:02:02,400 --> 00:02:04,920
>> ಶತಕಗಳನ್ನು ಇದು ಎಲ್ಲೆಡೆ ಹರಡುತ್ತದೆ.

42
00:02:04,920 --> 00:02:07,670
ಚಿತ್ರ ಪ್ರದರ್ಶನದ ಹೊಂದಿವೆ
ಯಾವಾಗಲೂ ಅಡ್ಡ ಎಂದು.

43
00:02:07,670 --> 00:02:11,200
ಲಂಬ ವೀಡಿಯೊಗಳನ್ನು ಸಾಧ್ಯವಾಗದಿದ್ದ
ಒಪ್ಪಿತ, ಚಿತ್ರ

44
00:02:11,200 --> 00:02:13,930
ಎತ್ತರದ ಮತ್ತು ಸ್ನಾನ ಮಾಡಬೇಕು.

45
00:02:13,930 --> 00:02:17,710
>> ಶತಕಗಳನ್ನು ಚಿತ್ರ ಎಲ್ಲಾ ಎಂದು
ಮನೆಯನ್ನು ನೆಲಸಮ ಮಾಡಿ ಮರು ಮಾಡಲು ಹೊಂದಿವೆ.

46
00:02:17,710 --> 00:02:22,090
ಮತ್ತು ಸಮಯ ಅವರು ಮರುನಿರ್ಮಿಸಲಾಯಿತು,
ಮಿಲಾ ಕುನಿಸ್ ಹಳೆಯ ಮತ್ತು ಕೊಳಕು ಎಂದು.

47
00:02:22,090 --> 00:02:24,342
>> -Birds ಅವನ್ನು ಕುಸಿತಕ್ಕೆ ಮತ್ತು ಸಾಯುತ್ತಾರೆ.

48
00:02:24,342 --> 00:02:26,530
>> -We'll ಎಲ್ಲ ಕಠಿಣ ಪಡೆಯಲು
ಅಪ್ ಹುಡುಕುವುದರಲ್ಲಿ ಕತ್ತಿನ.

49
00:02:26,530 --> 00:02:29,800
>> ಶತಕಗಳನ್ನು ಯಾರೂ ಕುಳಿತು
ಮುಂದಿನ ಸಾಲು ಮತ್ತೆ.

50
00:02:29,800 --> 00:02:37,170
>> -George ಲ್ಯೂಕಾಸ್ ಮರು ಬಿಡುಗಡೆ ಮಾಡುತ್ತದೆ ಸ್ಟಾರ್
ವಾರ್ಸ್ ಸ್ನಾನ ಆವೃತ್ತಿಯಲ್ಲಿ ಮತ್ತೆ.

51
00:02:37,170 --> 00:02:41,860
>> -ನಾನು ಹೇಳಲು ನಿಜವಾಗಿಯೂ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ನಾನು ಹೇಳಲು ಬಯಸುತ್ತೇನೆ ಎಂದು ಕಥೆ.

52
00:02:41,860 --> 00:02:46,030
ಈ ನನಗೆ ಒಂದು ದೊಡ್ಡ ಅವಕಾಶ
ಹೊಸ ತಂತ್ರಜ್ಞಾನ ಪ್ರಾಯೋಗಿಕವಾಗಿ.

53
00:02:46,030 --> 00:02:48,150
>> ಒಂದು ಎಳೆತ -You're.

54
00:02:48,150 --> 00:02:54,430
>> ಮೊಬೈಲ್ ಸಾಧನದ ಬಳಸಲಾಗುತ್ತದೆ -Every ಸಮಯ
ವೀಡಿಯೊ ರೆಕಾರ್ಡ್ ಮಾಡಿ, ಪ್ರಲೋಭನೆ ಇಲ್ಲ.

55
00:02:54,430 --> 00:02:56,370
ಜಸ್ಟ್ ಯಾವುದೇ ಹೇಳುತ್ತಾರೆ.

56
00:02:56,370 --> 00:03:00,116
ಜಾರ್ಜ್ ಲ್ಯೂಕಾಸ್ ಯಾವುದೇ ಸೇ.

57
00:03:00,116 --> 00:03:04,062
ಹಳೆಯ ಮಿಲಾ ಕುನಿಸ್ ಯಾವುದೇ ಸೇ.

58
00:03:04,062 --> 00:03:06,600
ಯಾವುದೇ ಲಂಬ ವೀಡಿಯೊಗಳನ್ನು ಸೇ.

59
00:03:06,600 --> 00:03:12,511
>> ನೀವು ಯಾರಾದರೂ ಮಾಡುತ್ತಿದ್ದೆ ನೋಡಿ ವೇಳೆ ಶತಕಗಳನ್ನು, ಹೇಳಲು
"ನೀವು ಬಲ ನಕಲಿ ಚಿತ್ರೀಕರಣ ಇಲ್ಲ!"

60
00:03:12,511 --> 00:03:15,433
>> [ಸಂಗೀತ]

61
00:03:15,433 --> 00:03:18,842

62
00:03:18,842 --> 00:03:19,830
>> [END ಪ್ಲೇಬ್ಯಾಕ್]

63
00:03:19,830 --> 00:03:23,702
>> [ಚಪ್ಪಾಳೆ]

64
00:03:23,702 --> 00:03:27,598
>> [ಆಡಿಯೋ ಔಟ್]

65
00:03:27,598 --> 00:03:44,041

66
00:03:44,041 --> 00:03:45,790
ರಾಬ್ ಬೌಡೆನ್: --simple
ಗೂಢಲಿಪೀಕರಣದ ರೂಪ,

67
00:03:45,790 --> 00:03:49,500
ಇದು ಮೂಲತಃ ಗೂಢಲಿಪೀಕರಣ ಹೊಂದಿದೆ
ರಹಸ್ಯ ಸಂದೇಶಗಳನ್ನು ಮತ್ತು ಅಸಂಕೇತೀಕರಣವನ್ನು.

68
00:03:49,500 --> 00:03:52,590
ಇಲ್ಲಿ ನಾವು ಒಂದು ಸರಳ ಆಟಿಕೆ ಹೊಂದಿರುತ್ತವೆ.

69
00:03:52,590 --> 00:03:56,900
ಮತ್ತು ಕಲ್ಪನೆ ಹೊರ ವರ್ತುಲ
ಒಳ ವರ್ತುಲ ಸುತ್ತ ತಿರುಗುತ್ತಿದೆ.

70
00:03:56,900 --> 00:04:01,610
ಮತ್ತು ನೀವು ನಾನು ಜೂಮ್ ಬಹುಶಃ ವೇಳೆ, ನೋಡಬಹುದು
, ಇದು ನೋಡಲು ಹಾರ್ಡ್ ಇಲ್ಲಿದೆ ಆ.

71
00:04:01,610 --> 00:04:05,090
ಆದರೆ, ಹಾಗೆ, ಸಂಖ್ಯೆ
1 ಹೊಂದಿವೆ ಚೆನ್ನಾಗಿ, ತೆರಳಿದರು.

72
00:04:05,090 --> 00:04:09,120
>> ಸಂಖ್ಯೆ 1 ಪತ್ರದ ನಕ್ಷೆಗಳು
ಪತ್ರದ ಎಕ್ಸ್, ಸಂಖ್ಯೆ 2 ನಕ್ಷೆಗಳು

73
00:04:09,120 --> 00:04:11,630
ಜೆ ಕಷ್ಟ ಮೀರಿ
ಮುಂದೆ ಸ್ಕಿಪ್ ಅಲ್ಲ.

74
00:04:11,630 --> 00:04:16,100
ಪತ್ರ 2 ಜೆ ನಕ್ಷೆಗಳು
ಸಂಖ್ಯೆ 3 ಆದ್ದರಿಂದ ಡಿ ನಕ್ಷೆ

75
00:04:16,100 --> 00:04:20,140
ಈ ಉಂಗುರವನ್ನು ನೀವು ನೀಡಬಹುದು
ಯಾರಾದರೂ ಒಂದು ಸಂದೇಶವನ್ನು 1, 2, 3.

76
00:04:20,140 --> 00:04:22,624
ಕೆಲವು ಕಾರಣಕ್ಕಾಗಿ ನೀವು
ಅವುಗಳನ್ನು XJD ಹೇಳಲು ಬಯಸುತ್ತೇನೆ.

77
00:04:22,624 --> 00:04:24,540
ಆದರೆ ನೀವು ಅವರಿಗೆ ನೀಡಬಹುದು
ಸಂಖ್ಯೆಗಳ ಕೆಲವು ಸಂದೇಶವನ್ನು,

78
00:04:24,540 --> 00:04:28,460
ಮತ್ತು ಅವರು ಈ ರಿಂಗ್ ಹೊಂದಿರುತ್ತವೆ ಅಲ್ಲಿಯವರೆಗೆ ಅವರು
ನೀವು ಹೇಳಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಡೀಕ್ರಿಪ್ಟ್.

79
00:04:28,460 --> 00:04:32,510
>> ಆದ್ದರಿಂದ ನೀವು ನೋಡಬಹುದು ಈ
ಗೂಢಲಿಪೀಕರಣದ ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಗೆ

80
00:04:32,510 --> 00:04:36,640
ಮೊದಲು ಕ್ರಿಸ್ಮಸ್ ಸುತ್ತ ವೇಳೆ
ನೀವು ಒಂದು ಕ್ರಿಸ್ಮಸ್ ಸ್ಟೋರಿ ವೀಕ್ಷಿಸಿದರು ಬಂದಿದೆ.

81
00:04:36,640 --> 00:04:38,520
ನೀವು ನೋಡಿಲ್ಲದಿದ್ದರೆ, ನೀವು
ಇದು ಮೊದಲು, ನಂತರ ಕೇವಲ

82
00:04:38,520 --> 00:04:41,060
ಅಕ್ಷರಶಃ ನಲ್ಲಿ TBS ಆನ್
ಕ್ರಿಸ್ಮಸ್ ಈವ್ ರಂದು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ,

83
00:04:41,060 --> 00:04:44,510
ಅವರು ಕೇವಲ ಮತ್ತೆ ಮತ್ತೆ ಅದನ್ನು ತೋರಿಸಲು ಕಾರಣ
ಇಡೀ ದಿನ ಒಂದರ ಹಿಂದೆ ಒಂದರಂತೆ ಬ್ಯಾಕ್.

84
00:04:44,510 --> 00:04:46,744
ಮತ್ತು ವೀಡಿಯೊ ಇದು.

85
00:04:46,744 --> 00:04:47,410
[ವೀಡಿಯೋ ಪ್ಲೇಬ್ಯಾಕ್]

86
00:04:47,410 --> 00:04:50,020
ಇದು ಎಲ್ಲಾ ಮತ್ತು ಬಗೆಬಗೆಯ ಕರೆಯಲಾಗುತ್ತದೆ -Be
ರಾಲ್ಫ್ ಪಾರ್ಕರ್ ಇಲ್ಲಿಂದ ಎಂದು

87
00:04:50,020 --> 00:04:52,850
ಲಿಟಲ್ ಸದಸ್ಯ ನೇಮಕ
ಆರ್ಫನ್ ಅನ್ನಿ ರಹಸ್ಯ ಸರ್ಕಲ್

88
00:04:52,850 --> 00:04:56,490
ಮತ್ತು ಎಲ್ಲಾ ಗೌರವಗಳು ಅರ್ಹತೆ ಇದೆ
ಮತ್ತು ಪ್ರಯೋಜನಗಳನ್ನು ಮಾಡಲಾದ ಸಂಭವಿಸುವ.

89
00:04:56,490 --> 00:04:59,010
ಲಿಟ್ಲ್ ಆರ್ಫನ್ ಅನ್ನಿ ಸಹಿ.

90
00:04:59,010 --> 00:05:03,120
ಶಾಯಿಯಲ್ಲಿ ಪಿಯರೆ ಆಂಡ್ರೆ Countersigned!

91
00:05:03,120 --> 00:05:07,460
ಗೌರವಗಳು ಮತ್ತು ಪ್ರಯೋಜನಗಳನ್ನು
ಈಗಾಗಲೇ ಒಂಬತ್ತನೆಯ ವಯಸ್ಸಿನಲ್ಲೇ!

92
00:05:07,460 --> 00:05:12,530
>> [ರೇಡಿಯೋ ಹಾರಿದಂತೆ]

93
00:05:12,530 --> 00:05:13,030
ಆನ್ ಕಮ್.

94
00:05:13,030 --> 00:05:14,000
ನ ಅದನ್ನು ಪಡೆಯಲು ಅವಕಾಶ.

95
00:05:14,000 --> 00:05:18,274
ನಾನು ಜಾಝ್ ಅಗತ್ಯವಿಲ್ಲ
ಕಳ್ಳಸಾಗಾಣಿಕೆದಾರರು ಮತ್ತು ಕಡಲ್ಗಳ್ಳರು ಬಗ್ಗೆ.

96
00:05:18,274 --> 00:05:20,440
ಜೊತೆ -listen ನಾಳೆ ರಾತ್ರಿ
ಸಮಾರೋಪ ಸಾಹಸ

97
00:05:20,440 --> 00:05:22,540
ಕಪ್ಪು ಪೈರೇಟ್ ಶಿಪ್ ನ.

98
00:05:22,540 --> 00:05:25,460
ಈಗ, ಇದು ಸಮಯ
ಅನ್ನಿ ರಹಸ್ಯ ಸಂದೇಶದಲ್ಲಿ

99
00:05:25,460 --> 00:05:28,620
ಸೀಕ್ರೆಟ್ ವೃತ್ತದ ನೀವು ಸದಸ್ಯರಿಗೆ.

100
00:05:28,620 --> 00:05:32,370
ಮಕ್ಕಳು, ಸದಸ್ಯರು ಮಾತ್ರ ನೆನಪಿಡಿ
ಅನ್ನಿ ರಹಸ್ಯ ವೃತ್ತದ

101
00:05:32,370 --> 00:05:34,880
ಅನ್ನಿ ರಹಸ್ಯ ಸಂದೇಶದಲ್ಲಿ ಡಿಕೋಡ್ ಮಾಡಬಹುದು.

102
00:05:34,880 --> 00:05:39,100
ನೆನಪಿಡಿ, ಅನ್ನಿ ನೀವು ಅವಲಂಬಿಸಿ ಇದೆ.

103
00:05:39,100 --> 00:05:41,660
B2 ನಿಮ್ಮ ಪಿನ್ಗಳು ಹೊಂದಿಸಿ.

104
00:05:41,660 --> 00:05:43,960
ಇಲ್ಲಿ ಸಂದೇಶ.

105
00:05:43,960 --> 00:05:44,680
12.

106
00:05:44,680 --> 00:05:45,180
11.

107
00:05:45,180 --> 00:05:45,679
2.

108
00:05:45,679 --> 00:05:48,110
-ನಾನು ನನ್ನ ಮೊದಲ ರಹಸ್ಯ ಸಭೆಯಲ್ಲಿ ಇದ್ದೇನೆ.

109
00:05:48,110 --> 00:05:49,030
>> -25.

110
00:05:49,030 --> 00:05:49,834
14.

111
00:05:49,834 --> 00:05:51,040
11.

112
00:05:51,040 --> 00:05:51,854
18.

113
00:05:51,854 --> 00:05:52,670
16.

114
00:05:52,670 --> 00:05:54,570
>> -OH, ಪಿಯರೆ ದೊಡ್ಡ ಧ್ವನಿ ಟುನೈಟ್ ಆಗಿದೆ.

115
00:05:54,570 --> 00:05:57,490
ನಾನು ಟುನೈಟ್ ಹೇಳಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ಸಂದೇಶವನ್ನು ನಿಜವಾಗಿಯೂ ಮುಖ್ಯವಾಗಿತ್ತು.

116
00:05:57,490 --> 00:05:57,990
-3.

117
00:05:57,990 --> 00:06:00,080
25.

118
00:06:00,080 --> 00:06:01,580
ಆ ಅನ್ನಿ ಸ್ವತಃ ಒಂದು ಸಂದೇಶವಾಗಿದೆ.

119
00:06:01,580 --> 00:06:02,880
ಯಾರಾದರೂ ಹೇಳಲು ಇಲ್ಲ, ನೆನಪಿಡಿ.

120
00:06:02,880 --> 00:06:07,840

121
00:06:07,840 --> 00:06:11,130
>> ಬೈ ಸೆಕೆಂಡುಗಳ ನಂತರ, ನಾನು ಮಾತ್ರ ಮನುಷ್ಯ
ಮನೆಯಲ್ಲಿ ಕೊಠಡಿ ಅಲ್ಲಿ ಒಂಬತ್ತು ಒಂದು ಹುಡುಗ

122
00:06:11,130 --> 00:06:15,830
ಗೌಪ್ಯತೆ ಮತ್ತು ಡಿಕೋಡ್ ಕುಳಿತು.

123
00:06:15,830 --> 00:06:16,620
ಆಹಾ!

124
00:06:16,620 --> 00:06:17,340
ಬಿ!

125
00:06:17,340 --> 00:06:20,210
ನಾನು ಮುಂದಿನ ಹೋದರು.

126
00:06:20,210 --> 00:06:23,300
ಇ ಮೊದಲ ಪದ "ವೆಂದು." ಆಗಿದೆ

127
00:06:23,300 --> 00:06:25,880
ಎಸ್ ಈಗ ಸುಲಭ ಬರುತ್ತಿತ್ತು.

128
00:06:25,880 --> 00:06:28,400
ಯು 25.

129
00:06:28,400 --> 00:06:30,528
ಎಂದು ಆರ್ ಇಲ್ಲಿದೆ

130
00:06:30,528 --> 00:06:31,278
ಕಮ್ ಆನ್, Ralphie!

131
00:06:31,278 --> 00:06:31,861
ನಾನು ಕಾರನ್ನು ಹೋಗಿ ಬಂದಿದೆ!

132
00:06:31,861 --> 00:06:33,182
ಬಲ ಕೆಳಗೆ -I'll, ಮಾ!

133
00:06:33,182 --> 00:06:36,038
ಜೀ ವಿಸ್.

134
00:06:36,038 --> 00:06:42,840
ಏನು ಮರೆಯಬೇಡಿ - ಟಿ ಒ "ಮರೆಯದಿರಿ"?

135
00:06:42,840 --> 00:06:44,770
ಲಿಟ್ಲ್ ಆರ್ಫನ್ ಏನು
ಅನ್ನಿ ಹೇಳಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ?

136
00:06:44,770 --> 00:06:46,381
ಏನು ಮರೆಯದಿರಿ?

137
00:06:46,381 --> 00:06:47,825
>> -Randy ಹೋಗಲು ದೊರೆತಿದೆ!

138
00:06:47,825 --> 00:06:48,866
ನೀವು ಬನ್ನಿ ಕಾಣಿಸುತ್ತದೆ?

139
00:06:48,866 --> 00:06:49,783
>> -ಎಲ್ಲಾ ಬಲ, ತಾಯಿ!

140
00:06:49,783 --> 00:06:51,786
ನಾನು ಹೊರಬರುತ್ತಾನೆ!

141
00:06:51,786 --> 00:06:53,606
ನಾನು ಈಗ ಹತ್ತಿರದಿಂದ ದೊರಕಿತು.

142
00:06:53,606 --> 00:06:55,550
ಒತ್ತಡ ವಿಫಲರಾಗಿದ್ದಾರೆ.

143
00:06:55,550 --> 00:06:57,050
ಇದು ಏನು?

144
00:06:57,050 --> 00:06:59,905
ಗ್ರಹದ ಅದೃಷ್ಟ
ಸಮತೋಲನ ಸ್ಥಗಿತಗೊಳ್ಳಬಹುದು!

145
00:06:59,905 --> 00:07:01,736
>> -Ralphie, ರಾಂಡಿ ಹೋಗಲು ಸಿಕ್ಕಿತು!

146
00:07:01,736 --> 00:07:05,680
>> ಜೋರಾಗಿ ಅಳುವುದು, ಬಲ ಔಟ್ -I'll!

147
00:07:05,680 --> 00:07:07,170
ಬಹುತೇಕ ಇಲ್ಲ!

148
00:07:07,170 --> 00:07:08,150
ನನ್ನ ಬೆರಳುಗಳು ಹಾರಿಸಿದರು.

149
00:07:08,150 --> 00:07:09,980
ನನ್ನ ಮನಸ್ಸಿನಲ್ಲಿ ಒಂದು ಉಕ್ಕಿನ ಬೋನು ಆಗಿತ್ತು.

150
00:07:09,980 --> 00:07:11,496
ಪ್ರತಿ ರಂಧ್ರಗಳ ಕಂಪಿಸುವ.

151
00:07:11,496 --> 00:07:13,268
ಇದು ಬಹುತೇಕ ಸ್ಪಷ್ಟವಾಗಿತ್ತು!

152
00:07:13,268 --> 00:07:13,767
ಹೌದು.

153
00:07:13,767 --> 00:07:14,609
ಹೌದು.

154
00:07:14,609 --> 00:07:15,108
ಹೌದು.

155
00:07:15,108 --> 00:07:16,449
ಹೌದು.

156
00:07:16,449 --> 00:07:20,240
ನಿಮ್ಮ ಓವಲ್ಟೈನ್ ಕುಡಿಯಲು ಮರೆಯದಿರಿ.

157
00:07:20,240 --> 00:07:20,740
ಓವಲ್ಟೈನ್?

158
00:07:20,740 --> 00:07:26,687

159
00:07:26,687 --> 00:07:27,520
ಒಂದು crummy ವಾಣಿಜ್ಯ?

160
00:07:27,520 --> 00:07:32,040

161
00:07:32,040 --> 00:07:34,920
ಒಂದು ಹೆಣ್ಣುನಾಯಿ ಮಗ.

162
00:07:34,920 --> 00:07:35,890
>> [END ಪ್ಲೇಬ್ಯಾಕ್]

163
00:07:35,890 --> 00:07:39,650
>> ರಾಬ್ ಬೌಡೆನ್: ಆದ್ದರಿಂದ ಹೇಗೆ
ಓವಲ್ಟೈನ್ ಗೂಢಲಿಪಿಶಾಸ್ತ್ರ ಸಂಬಂಧಿಸಿದೆ.

164
00:07:39,650 --> 00:07:42,290
ಮೂಲತಃ CS50 ಕೇವಲ ಪ್ರಚಾರ
ಓವಲ್ಟೈನ್, ಆದ್ದರಿಂದ ನಾವು ಸಾಧ್ಯವೋ

165
00:07:42,290 --> 00:07:44,400
ಓವಲ್ಟೈನ್ ಒಂದು crummy ವಾಣಿಜ್ಯ ಎಂದು.

166
00:07:44,400 --> 00:07:44,900
ಆಯ್ತು.

167
00:07:44,900 --> 00:07:47,120
ಈಗ ನಿಜವಾದ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನ.

168
00:07:47,120 --> 00:07:50,670
ಸೋಮವಾರ ನೆನಪಿಡಿ ನಾವು ಆಫ್ ಬಿಟ್ಟು
ತಂತಿಗಳನ್ನು ಆಳವಾಗಿ ಡೈವಿಂಗ್.

169
00:07:50,670 --> 00:07:52,820
ನಾವು ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಲಾಯಿತು
ಸ್ಟ್ರಿಂಗ್ "Zamyla."

170
00:07:52,820 --> 00:07:55,130
ನಾವು ಗುರುತಿಸಿ ಮಾಡಲಾಯಿತು
ನಾವು ಚಿಕಿತ್ಸೆ ಎಂದು ವಾಸ್ತವವಾಗಿ

171
00:07:55,130 --> 00:07:57,510
ಪಾತ್ರಗಳು ಒಂದು ಅನುಕ್ರಮ ", Zamyla".

172
00:07:57,510 --> 00:07:59,740
ಮತ್ತು ನಾವು ಕಲಿತ ನೆನಪು
ಬ್ರಾಕೆಟ್ ಸಂಕೇತನ.

173
00:07:59,740 --> 00:08:01,995
ಈ ಇರಿಸಲಾಗುತ್ತಿತ್ತು ಆದ್ದರಿಂದ
ನಂತರ ಸ್ಟ್ರಿಂಗ್ "ರು,"

174
00:08:01,995 --> 00:08:05,860
ನಾವು ಹೇಳಿದರು ವೇಳೆ ರು ಬ್ರಾಕೆಟ್ 0, ಎಂದು
ಅಕ್ಷರದ ರಾಜಧಾನಿ ಝಡ್ ಸೂಚಿಸುತ್ತದೆ

175
00:08:05,860 --> 00:08:09,790
ನಾವು ರು ಬ್ರಾಕೆಟ್ 1, ಹೇಳಿದರು ವೇಳೆ
ಮೊದಲ ಸಣ್ಣ ಒಂದು ಸೂಚಿಸುತ್ತದೆ,

176
00:08:09,790 --> 00:08:14,220
ಹೀಗೆ ರು ಬ್ರಾಕೆಟ್ 5 ವರೆಗೆ,
ಕಳೆದ ಒಂದು ಸೂಚಿಸುತ್ತದೆ.

177
00:08:14,220 --> 00:08:17,090
>> ಈಗ ನೆನಪು
ಈ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ, 6

178
00:08:17,090 --> 00:08:23,220
ಆದರೆ ಸ್ಟ್ರಿಂಗ್ ಸೂಚ್ಯಂಕಗಳು
0 5 ಮೂಲಕ, ಆ ಮೂಲಕ ಝಡ್ ಒಂದು ಕಾಲ.

179
00:08:23,220 --> 00:08:28,650
ಆದ್ದರಿಂದ ಈಗ ಒಂದು ದೊಡ್ಡ ಚಿತ್ರ ಸೂಕ್ತವಾದ
ನಿಮ್ಮ ಗಣಕದ ಮೆಮೊರಿ, ನಿಮ್ಮ RAM ನ.

180
00:08:28,650 --> 00:08:32,020
ಆದ್ದರಿಂದ ಎಲ್ಲೋ ಪ್ರೋಗ್ರಾಂ
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ

181
00:08:32,020 --> 00:08:34,780
Zamyla ಮರೆಯದಿರಿ ಅಗತ್ಯವಿದೆ
ಎಲ್ಲೋ ಮೆಮೊರಿ.

182
00:08:34,780 --> 00:08:36,029
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಸ್ವಯಂಸೇವಕ ಹೊಂದಬಹುದು?

183
00:08:36,029 --> 00:08:38,840

184
00:08:38,840 --> 00:08:40,181
ಹೌದು, ದಯವಿಟ್ಟು.

185
00:08:40,181 --> 00:08:50,120

186
00:08:50,120 --> 00:08:51,500
ನಿಮ್ಮ ಹೆಸರೇನು?

187
00:08:51,500 --> 00:08:52,410
>> ಡೀನ್: ಡೀನ್.

188
00:08:52,410 --> 00:08:53,550
>> ರಾಬ್ ಬೌಡೆನ್: ಡೀನ್?

189
00:08:53,550 --> 00:08:54,910
ಡೀನ್ ನೀವು ಭೇಟಿ ಚೆನ್ನಾಗಿರುತ್ತದೆ.

190
00:08:54,910 --> 00:08:58,240
ಇಲ್ಲಿ ಮೇಲೆ ಬರಲು, ಮತ್ತು
ನಾವು ನೀವು ಸೆಳೆಯಲು ಎಂದು ನೀನು

191
00:08:58,240 --> 00:09:00,740
ಮೆಮೊರಿ ನಮ್ಮ ಸಂತೋಷವನ್ನು ನಿಫ್ಟಿ ಲೇಔಟ್.

192
00:09:00,740 --> 00:09:05,950
ಈಗ ನಾನು ಮೆಮೊರಿ ಭಾವಿಸುತ್ತೇನೆ
ಬೈಟ್ಗಳು ಒಂದು ಉದ್ದ ಪಟ್ಟಿಯಲ್ಲಿ ಎಂದು,

193
00:09:05,950 --> 00:09:11,090
ಆದರೆ ಪ್ರದರ್ಶನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ನಾವು ಮಾಡುತ್ತೇವೆ
ಕೇವಲ ಕೆಳಗೆ ಬಲ, ಮೇಲಕ್ಕೆ ಬಿಟ್ಟು ಇಲ್ಲ.

194
00:09:11,090 --> 00:09:11,590
ಸರಿ?

195
00:09:11,590 --> 00:09:22,030
>> ಹಾಗಾಗಿ ತೋರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
Getstrings.c ಪ್ರೋಗ್ರಾಂ.

196
00:09:22,030 --> 00:09:25,760
ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯಕ್ರಮ
ಮಾಡುವ ನಾಲ್ಕು ತಂತಿಗಳ ವಿನಂತಿಸುತ್ತಿದೆ

197
00:09:25,760 --> 00:09:28,830
ಜೊತೆ ಬಳಕೆದಾರರಿಂದ
GetString ಮತ್ತು ನಂತರ ಮುದ್ರಣ

198
00:09:28,830 --> 00:09:30,950
ಯಾವುದೇ ಮೊದಲ ವಾಕ್ಯವೇ ಪ್ರವೇಶಿಸಿತು.

199
00:09:30,950 --> 00:09:32,840
ನಾವು ನಾಲ್ಕು ಮೂಲಕ ಎರಡು ನಿರ್ಲಕ್ಷಿಸುತ್ತಿಲ್ಲ.

200
00:09:32,840 --> 00:09:33,610
ಸರಿ.

201
00:09:33,610 --> 00:09:38,210
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಈಗ ಮಾಡಿದಾಗ
ನಾನು ಮೊದಲ ವಿನಂತಿಯನ್ನು S1.

202
00:09:38,210 --> 00:09:39,740
ಆದ್ದರಿಂದ ನೀವು ಕಂಪ್ಯೂಟರ್ ಇವೆ.

203
00:09:39,740 --> 00:09:41,680
ಮತ್ತು ನೀವು GetString ಕಾರ್ಯರೂಪಕ್ಕಿಳಿಸುವ.

204
00:09:41,680 --> 00:09:46,710
ಆದ್ದರಿಂದ ನೀವು ಸ್ಟ್ರಿಂಗ್ ಮನವಿ
ನನಗೆ, ಮತ್ತು ನಾನು, ಸರಿ, ಡೀನ್ ಹೇಳುತ್ತಾರೆ.

205
00:09:46,710 --> 00:09:47,900
ಸ್ಟ್ರಿಂಗ್ ನೀಡಿ "ಡೀನ್."

206
00:09:47,900 --> 00:09:50,300
>> ಆದ್ದರಿಂದ ಎಲ್ಲೋ ನೆನಪಿಗಾಗಿ ನೀವು
ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ "ಡೀನ್."

207
00:09:50,300 --> 00:09:52,160
ಆದ್ದರಿಂದ ಎಲ್ಲೋ ಮೆಮೊರಿ ಅದನ್ನು ಬರೆಯಲು.

208
00:09:52,160 --> 00:09:58,270

209
00:09:58,270 --> 00:09:59,210
ಪರ್ಫೆಕ್ಟ್.

210
00:09:59,210 --> 00:09:59,880
ಸರಿ.

211
00:09:59,880 --> 00:10:01,740
ಈಗ ನಾವು S2 ಮಾಡಿದ್ದಾರೆ.

212
00:10:01,740 --> 00:10:03,869
ಮತ್ತು ಎಸ್ 2 ಎಂದು ನಾನು
GetString ವಿನಂತಿಯನ್ನು.

213
00:10:03,869 --> 00:10:05,160
ಹಾಗಾಗಿ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನಮೂದಿಸಬಹುದು ಪಡೆಯಲಿದ್ದೇನೆ.

214
00:10:05,160 --> 00:10:08,720
ನಾನು ನಮೂದಿಸಿ ಪಡೆಯಲಿದ್ದೇನೆ "ಹನ್ನಾ."

215
00:10:08,720 --> 00:10:10,586
ಆದ್ದರಿಂದ ಎಲ್ಲೋ ಮೆಮೊರಿಗೆ "ಹನ್ನಾ" ನಮೂದಿಸಿ.

216
00:10:10,586 --> 00:10:18,860

217
00:10:18,860 --> 00:10:19,360
ಹೌದು.

218
00:10:19,360 --> 00:10:23,000
ಎ ಎಚ್.

219
00:10:23,000 --> 00:10:25,550
>> ಸರಿ, ಈಗ S3.

220
00:10:25,550 --> 00:10:28,380
ಮತ್ತು ಇನ್ನೊಂದು ಎಂದು ವಿಶೇಷವೇನು
GetString ಗೆ ಮನವಿ.

221
00:10:28,380 --> 00:10:37,020
ಆದ್ದರಿಂದ ಈಗ "ಮಾರಿಯಾ." ನಮೂದಿಸಿ

222
00:10:37,020 --> 00:10:37,520
ಆಯ್ತು.

223
00:10:37,520 --> 00:10:40,980
ತದನಂತರ ಕೊನೆಯ ಇಲ್ಲ
GetString ಗೆ ವಿನಂತಿಯನ್ನು, S4.

224
00:10:40,980 --> 00:10:42,580
ಆದ್ದರಿಂದ, ನಾನು ಗೊತ್ತಿಲ್ಲ.

225
00:10:42,580 --> 00:10:45,640
ಹೇಗೆ ನಾವು ಹೋಗಿ ಬಗ್ಗೆ
antidisestablishmentarianism.

226
00:10:45,640 --> 00:10:49,460
ಆದ್ದರಿಂದ ಮೆಮೊರಿಗೆ ನಮೂದಿಸಿ.

227
00:10:49,460 --> 00:10:50,400
ಹೌದು.

228
00:10:50,400 --> 00:10:53,970
ಆದ್ದರಿಂದ ಕೇವಲ "ರಾಬ್." ಹಾಗೆ

229
00:10:53,970 --> 00:10:54,560
>> ಸರಿ.

230
00:10:54,560 --> 00:10:58,410
ಏಕೆ ಈಗ ವಿವರಿಸುವುದಿಲ್ಲ
ನೀವು ಈ ಸ್ಥಳಗಳಲ್ಲಿ ಬಿಟ್ಟು?

231
00:10:58,410 --> 00:11:01,340
ಈ ಖಾಲಿ ಏಕೆ
ಇಲ್ಲಿ, ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ ಜಾಗ?

232
00:11:01,340 --> 00:11:05,170

233
00:11:05,170 --> 00:11:05,670
ಹೌದು.

234
00:11:05,670 --> 00:11:09,450
ನಾನು ಹೋದಾಗ ಗಮನಕ್ಕೆ
ಹಾಗಾಗಿ s1-- ಮುದ್ರಿಸಲು ನಾವು

235
00:11:09,450 --> 00:11:11,890
ಹೊಂದಿತ್ತು "ಹನ್ನಾ" ಚಾಲನೆಯಲ್ಲಿರುವ
ಬಲ ಮುಂದಿನ "ಡೀನ್"

236
00:11:11,890 --> 00:11:14,360
ನಾವು ಯಾವಾಗ ಗೊತ್ತು
ಸ್ಟ್ರಿಂಗ್ "ಡೀನ್" ಕೊನೆಗೊಳ್ಳುತ್ತದೆ?

237
00:11:14,360 --> 00:11:19,470
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ S1 ಮುದ್ರಣ ಹೊಂದಿರಬಹುದು
ಕೇವಲ "DeanHannahMariaRob" ಮುದ್ರಿತ

238
00:11:19,470 --> 00:11:22,720
ಇದು ಯಾವುದೇ ಸುಳಿವನ್ನು ಹೊಂದಿಲ್ಲ ವೇಳೆ
"ಡೀನ್" ವಾಸ್ತವವಾಗಿ ತುದಿಗಳನ್ನು ಮಾಡಿದಾಗ.

239
00:11:22,720 --> 00:11:23,240
>> ಆಯ್ತು.

240
00:11:23,240 --> 00:11:27,650
ಆದ್ದರಿಂದ ನೆನಪಿಗಾಗಿ ರೀತಿಯಲ್ಲಿ ನಾವು ವಾಸ್ತವವಾಗಿ
ಸ್ಟ್ರಿಂಗ್ ಈ ಕೊನೆಯಲ್ಲಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

241
00:11:27,650 --> 00:11:29,940
backslash ಶೂನ್ಯ ಹೊಂದಿದೆ.

242
00:11:29,940 --> 00:11:32,620
ಆದ್ದರಿಂದ ಈ ಜಾಗವನ್ನು ನಾವು ಬೇಕಾಗಿದ್ದಾರೆ ನಿಖರವಾಗಿ ಏನು.

243
00:11:32,620 --> 00:11:34,040
ಇದು ಒಂದು backslash ಶೂನ್ಯ ಇರಬೇಕು.

244
00:11:34,040 --> 00:11:37,690
ಈ, ಒಂದು backslash ಶೂನ್ಯ ಇರುತ್ತದೆ
ಮತ್ತು ಈ ಒಂದು backslash ಶೂನ್ಯ ಇರುತ್ತದೆ.

245
00:11:37,690 --> 00:11:41,585
ಮತ್ತು ನೀವು ಒಂದು ಅಸಾಧಾರಣ ಪ್ರಶಸ್ತಿ ಹೊಂದಬಹುದು
ಪರಿಪೂರ್ಣ ಸ್ವಯಂಸೇವಕ ಎಂದು.

246
00:11:41,585 --> 00:11:44,910

247
00:11:44,910 --> 00:11:45,860
ಒತ್ತಡದ ಚೆಂಡನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ!

248
00:11:45,860 --> 00:11:49,040

249
00:11:49,040 --> 00:11:49,700
>> ಸರಿ.

250
00:11:49,700 --> 00:11:54,420
ಆದ್ದರಿಂದ ಈ ಪಾತ್ರ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಶೂನ್ಯವಾಗಿರುತ್ತದೆ
ಹೇಗೆ ನಾವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ಸೂಚಿಸುತ್ತದೆ.

251
00:11:54,420 --> 00:11:57,120
ಇದು ಹೇಗೆ ಮಾಡಿದಾಗ ಯಾವುದೇ ಕಾರ್ಯಕ್ರಮದ
ಒಂದು ಸಾಲನ್ನು ಮುದ್ರಿಸಲು ಬಯಸಿದೆ,

252
00:11:57,120 --> 00:11:59,760
ನಾವು ಕಲಿತ ನೆನಪಿದೆ how-- ಅಷ್ಟೇ
strlen ಕಾರ್ಯ ಕಳೆದ ವಾರ?

253
00:11:59,760 --> 00:12:00,940
ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ?

254
00:12:00,940 --> 00:12:03,770
ಸ್ಟ್ರಿಂಗ್ ಉದ್ದದ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಹೇಗೆ
ಸ್ಟ್ರಿಂಗ್ ಎಷ್ಟು ನಿರ್ಧರಿಸಲು.

255
00:12:03,770 --> 00:12:05,810
ಇದು ಕೇವಲ iterating ಇಡುತ್ತದೆ
ಪಾತ್ರಗಳ ಮೇಲೆ

256
00:12:05,810 --> 00:12:08,217
ಇದು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ ರವರೆಗೆ
ಶೂನ್ಯ ಪಾತ್ರದಲ್ಲಿ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್.

257
00:12:08,217 --> 00:12:11,050
ಪ್ರಮುಖ ವಿಷಯ ಅರ್ಥ ಆದ್ದರಿಂದ
backslash ಶೂನ್ಯ ಪಾತ್ರದಲ್ಲಿ ಬಗ್ಗೆ

258
00:12:11,050 --> 00:12:14,950
ಇದು ನಿರೂಪಿಸಲಾಗಿದೆ ಇದೆ
ಬಿಟ್ಗಳು ಎಲ್ಲಾ ಸೊನ್ನೆಗಳು ಮೂಲಕ.

259
00:12:14,950 --> 00:12:18,980
ಆದ್ದರಿಂದ ಈ ವಿಶಿಷ್ಟ ಗಮನಿಸಿ
ಶೂನ್ಯ ಪಾತ್ರ.

260
00:12:18,980 --> 00:12:23,010
ಆದ್ದರಿಂದ ಶೂನ್ಯ ಪಾತ್ರ, ನೀವು ನೆನಪಿಡುವ ವೇಳೆ
ಉದಾಹರಣೆಗೆ ಅವರು ಕೊನೆಯಲ್ಲಿ ನೀಡಿದ

261
00:12:23,010 --> 00:12:27,360
ಉಪನ್ಯಾಸ ಪಾತ್ರಗಳು ನಕ್ಷೆ ಅಲ್ಲಿ
65 ಬಂಡವಾಳ ನಕ್ಷೆಗಳು ರೀತಿಯ to--.

262
00:12:27,360 --> 00:12:29,130
97 ಒಂದು ನಕ್ಷೆಗಳು ಸಣ್ಣ.

263
00:12:29,130 --> 00:12:30,890
ಸಣ್ಣ ಬೌ 98 ಎಂದು.

264
00:12:30,890 --> 00:12:35,220
ಆದ್ದರಿಂದ ಸಂಖ್ಯೆ 0 ನಕ್ಷೆಗಳು ನಾನು ಹಾಗೆ to--
ನನ್ನ ತಲೆಯ ಮೇಲಿನ ಆಫ್ ತಿಳಿದಿದೆ.

265
00:12:35,220 --> 00:12:36,400
44 ಅಥವಾ 45.

266
00:12:36,400 --> 00:12:37,890
ಎಲ್ಲೋ ಆ ಪ್ರದೇಶದಲ್ಲಿ.

267
00:12:37,890 --> 00:12:40,850
>> ಆದ್ದರಿಂದ ಅಕ್ಷರ 0 ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ನಿಖರವಾಗಿ.

268
00:12:40,850 --> 00:12:44,350
ಆದರೆ backslash ಶೂನ್ಯ
ಎಲ್ಲಾ ಶೂನ್ಯ ಬಿಟ್ಗಳ ನಕ್ಷೆಗಳು.

269
00:12:44,350 --> 00:12:46,380
ಆದ್ದರಿಂದ ಒಂದು ವ್ಯತ್ಯಾಸ ಇಲ್ಲ
backslash ಶೂನ್ಯ ನಡುವೆ,

270
00:12:46,380 --> 00:12:48,450
ಇದು ನಾವು ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಕರೆ ಮಾಡುತ್ತೇವೆ.

271
00:12:48,450 --> 00:12:53,210
ಒಂದು ವ್ಯತ್ಯಾಸ ನಡುವೆ ಇಲ್ಲ
backslash ಶೂನ್ಯ ಮತ್ತು ಪಾತ್ರ ಶೂನ್ಯ.

272
00:12:53,210 --> 00:12:54,350
>> ಆಯ್ತು.

273
00:12:54,350 --> 00:12:57,520
ಆದ್ದರಿಂದ ತಂತಿಗಳನ್ನು ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಮಾತನಾಡುವ.

274
00:12:57,520 --> 00:13:01,470
ಆದ್ದರಿಂದ ನಾವು ಈ ಹೇಗೆ ಇಲ್ಲಿ ನೋಡಿ
ಇದು ಮೆಮೊರಿ ಹಾಕಲ್ಪಟ್ಟಿತ್ತು.

275
00:13:01,470 --> 00:13:07,940
ಆದ್ದರಿಂದ ಒಂದು ಅನುಕ್ರಮ ತಂತಿಗಳ ಈ ಕಲ್ಪನೆಯನ್ನು
ಅಕ್ಷರಗಳು ಅಧಿಕೃತ ಕಂಪ್ಯೂಟರ್ ಆದ್ದರಿಂದ

276
00:13:07,940 --> 00:13:10,750
ದೃಶ್ಯಾವಳಿಯ sciency ಪದವನ್ನು ಒಂದು ರಚನೆ.

277
00:13:10,750 --> 00:13:13,790
ಆದ್ದರಿಂದ ನಾವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಕರೆಯುತ್ತಾನೆ
ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

278
00:13:13,790 --> 00:13:17,770
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಇತರ ಡೇಟಾವನ್ನು ಇವೆ
ನಾವು ಹೊರಗೆ ಸಾಲುಗಳು ಮಾಡಬಹುದಾದ ರೀತಿಯ.

279
00:13:17,770 --> 00:13:19,975
>> ಆದ್ದರಿಂದ ಈ ಹುರಿದುಂಬಿಸುವ, ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡಿ.

280
00:13:19,975 --> 00:13:22,810

281
00:13:22,810 --> 00:13:29,812
ನಾವು ನಾನು ಮಾಡುತ್ತೇವೆ ages0.c ಕರೆ ಮಾಡುತ್ತೇವೆ
ನಕಲಿಸಿ ಮತ್ತು ನಮ್ಮ ಟೆಂಪ್ಲೇಟ್ ಅಂಟಿಸಿ.

282
00:13:29,812 --> 00:13:32,470

283
00:13:32,470 --> 00:13:33,410
ಸರಿ.

284
00:13:33,410 --> 00:13:39,378
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಹಾಗಾಗಿ ನಾವು
ಮಾಡಲು ಬಯಸುವ ವಯಸ್ಸು ದೋಚಿದ ಆಗಿದೆ

285
00:13:39,378 --> 00:13:45,160
ಹಾದಿಯಲ್ಲಿ ಮೂರು ವಿದ್ಯಾರ್ಥಿಗಳು.

286
00:13:45,160 --> 00:13:49,240
ನಾವು ತಿಳಿದಿರುವ ಇಂಟ್ age--
ಮತ್ತು ಈಗ ನಾನು 0 ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ.

287
00:13:49,240 --> 00:13:53,140
ಆದ್ದರಿಂದ ನೀವು age1 ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ, ಆದರೆ ಇರಬಹುದು
ಉದ್ದೇಶಗಳಿಗಾಗಿ ನಾವು ಸ್ವಲ್ಪ ನೋಡುತ್ತಾರೆ,

288
00:13:53,140 --> 00:13:57,187
ನಾನು ಇಂಟ್ age0 GetInt ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳುತ್ತೇನೆ.

289
00:13:57,187 --> 00:13:59,270
GetInt ಅದೇ ಕರೆ ಆದ್ದರಿಂದ
ನಾವು ನಾನು ಬಳಸಿಕೊಂಡು ನಾವು

290
00:13:59,270 --> 00:14:01,561
ಪ್ರೇರೇಪಿಸಿತು ಎಂಬುದನ್ನೂ ಇಲ್ಲ
"ನನಗೆ ವಯಸ್ಸು ನೀಡಿ.", ಎಂದು

291
00:14:01,561 --> 00:14:03,120
ಆದರೆ ಅದನ್ನು ಕೋರುತ್ತಾನೆ.

292
00:14:03,120 --> 00:14:06,510
>> ಮತ್ತು age1 GetInt ಸಮನಾಗಿರುತ್ತದೆ.

293
00:14:06,510 --> 00:14:09,600
ಮತ್ತು ಇಂಟ್ age2 GetInt ಸಮನಾಗಿರುತ್ತದೆ.

294
00:14:09,600 --> 00:14:14,070
ಆದ್ದರಿಂದ, ಮತ್ತೆ, ಮೂರು ವಿದ್ಯಾರ್ಥಿಗಳು, ಆದರೆ
ಅಂತಿಮವಾಗಿ ವೇರಿಯಬಲ್ ಸೂಚ್ಯಂಕಗಳು

295
00:14:14,070 --> 00:14:16,890
age2 ಮೂಲಕ age0 ಇವೆ.

296
00:14:16,890 --> 00:14:17,550
ಸರಿ.

297
00:14:17,550 --> 00:14:23,960
ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯಕ್ರಮ ಮಾಡುತ್ತಾರೆ ಯಾವುದೇ
ನಾವು age0, age1, ಮತ್ತು age2 ಬಯಸುವ,

298
00:14:23,960 --> 00:14:27,670
ಆದರೆ ಈ ಕಾರ್ಯಕ್ರಮ ಅಂತಿಮವಾಗಿ
ಮೂರು ವಿದ್ಯಾರ್ಥಿಗಳು ಕೆಲಸ.

299
00:14:27,670 --> 00:14:28,380
>> ಸರಿ.

300
00:14:28,380 --> 00:14:32,110
ಈಗ ನಾನು ನಾಲ್ಕು ವಿದ್ಯಾರ್ಥಿಗಳು ಬಯಸಿದರೆ?

301
00:14:32,110 --> 00:14:36,000
ನಾನು ಹಿಂದಕ್ಕೆ ಹೋಗಬೇಕಾಗುತ್ತದೆ ಹೋಗುವ ಬಾಗುತ್ತೇನೆ
ನನ್ನ ಕೋಡ್ ಒಳಗೆ, ಕಾಮೆಂಟ್ ಬದಲಾಯಿಸಲು,

302
00:14:36,000 --> 00:14:39,840
ಮತ್ತು ಈಗ ನಾವು ಒಂದು ಇಂಟ್ ಹೊಂದಿವೆ
age3 GetInt ಸಮನಾಗಿರುತ್ತದೆ.

303
00:14:39,840 --> 00:14:40,610
ಸರಿ.

304
00:14:40,610 --> 00:14:43,660
ಆದ್ದರಿಂದ ಯಾರು ಇಲ್ಲಿ ಸಮಸ್ಯೆ ನೋಡುತ್ತಾನೆ?

305
00:14:43,660 --> 00:14:47,310
ಸಮಸ್ಯೆ ಏನು
ಸೆಟಪ್ ಈ ರೀತಿಯ?

306
00:14:47,310 --> 00:14:47,810
ಹೌದು.

307
00:14:47,810 --> 00:14:53,110

308
00:14:53,110 --> 00:14:53,610
ಹೌದು.

309
00:14:53,610 --> 00:14:56,360
ನಾವು ಒಂದು ರಚಿಸುತ್ತಿದೆ
ಪ್ರತಿ ವಿದ್ಯಾರ್ಥಿ ವೇರಿಯಬಲ್.

310
00:14:56,360 --> 00:15:00,140
ಈಗ ಆ ಕೆಲಸ, ಆದರೆ
ಅಂತಿಮವಾಗಿ ಈಗ ನಾನು ವೇಳೆ

311
00:15:00,140 --> 00:15:06,500
ನಾನು ವಯಸ್ಸಿನಲ್ಲಿ ದೋಚಿದ ಬಯಸುವ ", ಹೇಳುತ್ತಾರೆ
ಎಂಟು ವಿದ್ಯಾರ್ಥಿಗಳು ಅಥವಾ 16 ವಿದ್ಯಾರ್ಥಿಗಳು

312
00:15:06,500 --> 00:15:11,340
ಅಥವಾ ಆದಾಗ್ಯೂ ಅನೇಕ ವಿದ್ಯಾರ್ಥಿಗಳು
CS50 ರಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ನೂರಾರು

313
00:15:11,340 --> 00:15:16,750
ಅಥವಾ ಆವರಣದಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ಸಾವಿರಾರು
ಅಥವಾ ವಿಶ್ವದ ಜನರ ಶತಕೋಟಿ?

314
00:15:16,750 --> 00:15:19,130
ಆದ್ದರಿಂದ ಅಂತಿಮವಾಗಿ ಈ ಸಮರ್ಥನೀಯ ಅಲ್ಲ.

315
00:15:19,130 --> 00:15:21,990
ನೀವೇ ನಕಲು ನೋಡಿ ಯಾವುದೇ ಸಮಯ
ಮತ್ತು ಈ ರೀತಿಯ ಅಂಟಿಸಲು ಕೋಡ್

316
00:15:21,990 --> 00:15:25,050
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಭಾವಿಸಬೇಕು
ಉತ್ತಮ ಮಾರ್ಗವಿಲ್ಲ ಎಂದು.

317
00:15:25,050 --> 00:15:31,290
>> ನಾವು ಪರಿಚಯಿಸಲು ಅಲ್ಲಿ ಆದ್ದರಿಂದ ಇದು
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಣೆ.

318
00:15:31,290 --> 00:15:34,564
ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದ,
ಈ ಯಾವ ಸಾಮಾನ್ಯ ಸ್ವರೂಪವಾಗಿದೆ

319
00:15:34,564 --> 00:15:35,480
ಕಾಣುವಂತೆ ಹೋಗುತ್ತದೆ.

320
00:15:35,480 --> 00:15:36,664
ನಾವು ರೀತಿಯ ಹೇಳಲು ನೀನು.

321
00:15:36,664 --> 00:15:38,830
ಮತ್ತು ನಾವು ನೀನು
ವ್ಯೂಹ ಹೆಸರನ್ನು,

322
00:15:38,830 --> 00:15:41,150
ನಾವು ಯಾವುದೇ ವೇರಿಯಬಲ್ ವ್ಯಾಖ್ಯಾನಿಸಲು.

323
00:15:41,150 --> 00:15:43,980
ತದನಂತರ ಅಂತಿಮವಾಗಿ ನಾವು ಬಳಸುತ್ತಿರುವ
ಈ ಬ್ರಾಕೆಟ್ ಸಂಕೇತಗಳನ್ನು ಮತ್ತೆ

324
00:15:43,980 --> 00:15:47,480
ಆದರೆ ಒಂದು ವಿಭಿನ್ನ ಸಂದರ್ಭದಲ್ಲಿ
ಹೇಗೆ ನಾವು ಮೊದಲೇ ಇದು ಬಳಸುತ್ತಿದ್ದರು.

325
00:15:47,480 --> 00:15:51,860
>> ಇಲ್ಲಿ ಈ ಒಂದು ಸಾಮಾನ್ಯ ತೋರುತ್ತಿದೆ
ನಾವು ನೋಡಿದ ವೇರಿಯಬಲ್ ಘೋಷಣೆ.

326
00:15:51,860 --> 00:15:54,890
ನಾವು ಮೊದಲು ಇಂಟ್ X ಅರೆ ಕೊಲೊನ್ ನೋಡಿದ.

327
00:15:54,890 --> 00:16:00,020
ಸರಿ ಈಗ ನಾವು ಏನೋ ನೋಡಿ
ಇಂಟ್ X ಆವರಣ 5.

328
00:16:00,020 --> 00:16:04,020
ಮತ್ತು ಈ ಕಲ್ಪನೆಯನ್ನು ಹಾಕುವ
ನಾವು ಹೊಂದಿಲ್ಲ ಎಂದು GetInt ಪ್ರೋಗ್ರಾಂ

329
00:16:04,020 --> 00:16:08,850
ಆದ್ದರಿಂದ ನಾವು ಬಳಸಿಕೊಂಡು
ಅದೇ ರೀತಿಯಲ್ಲಿ ಈ.

330
00:16:08,850 --> 00:16:13,630
>> ನಾವು ಬಳಸಲು ಒಲವು ಸಿಎಸ್ ಹೇಳುತ್ತಾರೆ
ಏನೋ ಸಂಖ್ಯೆ ಎನ್.

331
00:16:13,630 --> 00:16:16,150
ಇಲ್ಲಿ ನಾವು ನೀನು
ನಾಲ್ಕು ವಿದ್ಯಾರ್ಥಿಗಳು ಶೇಖರಿಸಿಡಲು.

332
00:16:16,150 --> 00:16:25,960
ಮತ್ತು ಈಗ ನಾವು ಇಂಟ್ ವಯಸ್ಸು ಹೇಳಬಹುದು
ಬ್ರಾಕೆಟ್ ಸಾಕಷ್ಟು yet-- ಪಡೆಯಲು ಸೂಚನೆ

333
00:16:25,960 --> 00:16:32,210
ನಾಲ್ಕು ವಿದ್ಯಾರ್ಥಿಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು.

334
00:16:32,210 --> 00:16:38,050
ಆದ್ದರಿಂದ ಈ ಕಾಣಿಸುವುದು
ಮೆಮೊರಿ ಈ ಸಮನಾಗಿರುತ್ತದೆ.

335
00:16:38,050 --> 00:16:39,570
ಈ ತೆರವುಗೊಳಿಸಿ.

336
00:16:39,570 --> 00:16:46,606
ನಾವು ಎಲ್ಲೋ ಎಂದು ನೀನು
ಮೆಮೊರಿ ರಲ್ಲಿ ನಾನು ಈ ಅವಕಾಶ ಮಾಡುತ್ತೇವೆ.

337
00:16:46,606 --> 00:16:52,690

338
00:16:52,690 --> 00:16:53,808
>> ಆದ್ದರಿಂದ ಎಲ್ಲೋ ನೆನಪಿಗಾಗಿ.

339
00:16:53,808 --> 00:16:58,760

340
00:16:58,760 --> 00:16:59,727
ಒಂದು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು.

341
00:16:59,727 --> 00:17:03,383

342
00:17:03,383 --> 00:17:09,849
ನಾವು ಸತತವಾಗಿ ನಾಲ್ಕು ಪೂರ್ಣಾಂಕಗಳ ಹೊಂದಿವೆ
ನಾಲ್ಕು ಪೂರ್ಣಾಂಕಗಳ ಈ ಶ್ರೇಣಿಗೆ.

343
00:17:09,849 --> 00:17:13,820
ಆದ್ದರಿಂದ, ಪ್ರಸ್ತುತ, ಏನು
ಈ ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಒಂದು ಗಾತ್ರವನ್ನು?

344
00:17:13,820 --> 00:17:17,190

345
00:17:17,190 --> 00:17:17,690
ಹೌದು.

346
00:17:17,690 --> 00:17:18,390
ಇದು ನಾಲ್ಕು ಬೈಟ್ಗಳು ಇಲ್ಲಿದೆ.

347
00:17:18,390 --> 00:17:19,690
32 ಬಿಟ್ಗಳು.

348
00:17:19,690 --> 00:17:22,310
ಈಗ ಈ ಭಿನ್ನವಾಗಿದೆ
ಶ್ರೇಣಿಯನ್ನು ನಾವು

349
00:17:22,310 --> 00:17:24,020
ಪಾತ್ರಗಳ ಹಿಂದಿನ ರಚನೆಯ ಕಂಡಿತು.

350
00:17:24,020 --> 00:17:28,540
ಒಂದು ಸಾಲಿನಲ್ಲಿ ಪ್ರತಿ ಬಾಕ್ಸ್, ಒಂದೇ ಬೈಟ್ ಆಗಿತ್ತು
ಒಂದು ಪಾತ್ರ ಒಂದೇ ಬೈಟ್ ಏಕೆಂದರೆ.

351
00:17:28,540 --> 00:17:32,170
ಆದರೆ ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಪ್ರತಿ
ಬಾಕ್ಸ್ ಸಲುವಾಗಿ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಎಂದು ಹೊಂದಿದೆ

352
00:17:32,170 --> 00:17:34,060
ಇಡೀ ಪೂರ್ಣಾಂಕ ಹೊಂದಿಕೊಳ್ಳಲು.

353
00:17:34,060 --> 00:17:37,197
ಆದ್ದರಿಂದ ಈ ಯಾವ ಒಂದು ಶ್ರೇಣಿಯನ್ನು
ನಾಲ್ಕು ints ರೀತಿ ಎಂದು.

354
00:17:37,197 --> 00:17:40,510

355
00:17:40,510 --> 00:17:43,870
>> ತದನಂತರ ಕೋಡ್ ಮರಳಿ.

356
00:17:43,870 --> 00:17:47,460
ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಅಂಗಡಿ ಬಯಸುವ
ಆ ರಚನೆಯ ಒಳಗೆ ಪೂರ್ಣಾಂಕಗಳ.

357
00:17:47,460 --> 00:17:53,470
ಈಗ ಈ ತುಂಬಾ ತುಂಬಾ, ತುಂಬಾ ಆಗಿದೆ
ಹಂತದಲ್ಲಿ ಅದು ಸಾಮಾನ್ಯ ಮಾದರಿ

358
00:17:53,470 --> 00:17:54,680
ಸ್ನಾಯು ಮೆಮೊರಿ ಆಗಲು.

359
00:17:54,680 --> 00:17:56,710
ಹಾಗಾಗಿ 0 ಸಮನಾಗಿರುತ್ತದೆ ಇಂಟ್.

360
00:17:56,710 --> 00:17:57,940
ನಾನು n ಗಿಂತ ಕಡಿಮೆ.

361
00:17:57,940 --> 00:18:01,850
ನಾನು ಜೊತೆಗೆ ಹೆಚ್ಚು.

362
00:18:01,850 --> 00:18:05,790
ವಯಸ್ಸು ಬ್ರಾಕೆಟ್ ನಾನು GetInt ಸಮನಾಗಿರುತ್ತದೆ.

363
00:18:05,790 --> 00:18:15,100
>> ಆದ್ದರಿಂದ ಈ ಲೂಪ್, ಈ ವಿಧಾನವು ಕೆಲವು
ನೀವು ಬಹಳ ಬಳಸಲಾಗುತ್ತದೆ ಮಾಡಬೇಕು.

364
00:18:15,100 --> 00:18:20,010
ಆದ್ದರಿಂದ ಈ ಸಾಮಾನ್ಯವಾಗಿ ಎಷ್ಟು ನಾವು ತಿನ್ನುವೆ
ಯಾವುದೇ ರಚನೆಯ ಮೇಲೆ ತಿರುಗಿ.

365
00:18:20,010 --> 00:18:23,690
ಈಗ ಈ ರೀತಿಯ ಗಮನಕ್ಕೆ
ಆರಂಭದಿಂದಲೂ ಏಕೆ ವಿವರಿಸುತ್ತದೆ

366
00:18:23,690 --> 00:18:29,870
ನಾವು ಕುಣಿಕೆಗಳು ಇಂಟ್ ಹೋಗುವ ಹೊಂದಿರಲಿಲ್ಲ
ನಾನು ಕಡಿಮೆ ಅಥವಾ 10 ಸಮಾನವಾಗಿರುತ್ತದೆ, 1 ಸಮನಾಗಿರುತ್ತದೆ.

367
00:18:29,870 --> 00:18:34,200
ಆರಂಭಿಸಿ ಎಂದು ಎಂಬ ಕಾರಣಕ್ಕೆ
ಶೂನ್ಯ ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ಈ ಕೆಲಸ ಮಾಡುತ್ತದೆ.

368
00:18:34,200 --> 00:18:36,270
ಆದ್ದರಿಂದ ಸರಣಿಗಳ ಸೂಚ್ಯಂಕದೊಡನೆ ಸೊನ್ನೆ.

369
00:18:36,270 --> 00:18:40,360
ಈ ರಚನೆಯ ಉದ್ದ 4 ವೇಳೆ,
ಸೂಚ್ಯಂಕಗಳು 3 ಮೂಲಕ 0.

370
00:18:40,360 --> 00:18:42,880
>> ಮೊದಲ ಮೂಲಕ
ಲೂಪ್ ಈ ಪುನರಾವರ್ತನೆ

371
00:18:42,880 --> 00:18:49,930
ನಾವು ವಯಸ್ಸು ಸ್ಥಾಪನೆಗೆ ನೀನು
GetInt ಕರೆ ಸಮಾನವಾಗಿರುತ್ತದೆ ಬ್ರಾಕೆಟ್ 0.

372
00:18:49,930 --> 00:18:52,440
ಹಾಗಾಗಿ ವಾಟೆವರ್ ಹ್ಯಾಪನ್ಡ್
ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ನಮೂದಿಸಿ.

373
00:18:52,440 --> 00:18:56,970
ಎರಡನೇ ಪಾಸ್, ನಾವು ಆರ್
GetInt ಮಾಡಲು age1 ಸಮಾನ ಹೊಂದಿಸುವ.

374
00:18:56,970 --> 00:18:58,230
ಮೂರನೇ ಪಾಸ್, age2.

375
00:18:58,230 --> 00:18:59,880
ಅಂತಿಮ ಪಾಸ್ age3.

376
00:18:59,880 --> 00:19:05,750
ಲೂಪ್ ಮೊದಲ ಪಾಸ್ ಆದ್ದರಿಂದ
ನಾನು ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ಸಂಖ್ಯೆ 4 ನಮೂದಿಸಿ

377
00:19:05,750 --> 00:19:07,740
ನಾವು ಇಲ್ಲಿ 4 ಸೇರಿಸಲು ಮಾಡುತ್ತೇವೆ.

378
00:19:07,740 --> 00:19:11,470
ನಾನು ನಮೂದಿಸಿ ಎರಡನೇ ಪಾಸ್ ಮೇಲೆ ವೇಳೆ
50 ನಾವು ಇಲ್ಲಿ 50 ಹಾಕುತ್ತೇವೆ.

379
00:19:11,470 --> 00:19:15,180
ಮೂರನೇ ಪಾಸ್ ಮೇಲೆ ನಾನು ಬಹುಶಃ
ನಮೂದಿಸಿ 1 ಋಣಾತ್ಮಕ, 1 ಋಣಾತ್ಮಕ,

380
00:19:15,180 --> 00:19:21,810
ಮತ್ತು ನಂತರ ಅಂತಿಮವಾಗಿ ನಾನು 0 ಆಗಿತ್ತು ನಮೂದಿಸಿದರೆ ಮತ್ತು
ಈಗ ಈ ಸೂಚ್ಯಂಕ ಮೂರು ನೆನಪು.

381
00:19:21,810 --> 00:19:25,350
>> ನಾವು ಲೂಪ್ ಬ್ಯಾಕ್ ನಂತರ, ನಾನು
ಹೋಗುವ 4 ವೃದ್ಧಿಯಾಗಲ್ಪಡಬಹುದು ಎಂದು.

382
00:19:25,350 --> 00:19:27,770
ನಾನು ಇನ್ನು ಮುಂದೆ 4 ಇದು ಎನ್, ಕಡಿಮೆ.

383
00:19:27,770 --> 00:19:29,840
ನಾವು ಲೂಪ್ ಭೇದಿಸಿ.

384
00:19:29,840 --> 00:19:32,578
ಆದ್ದರಿಂದ ಈ ತಪ್ಪು ಏನು ಎಂದು?

385
00:19:32,578 --> 00:19:38,140

386
00:19:38,140 --> 00:19:38,729
[ಕೇಳಿಸುವುದಿಲ್ಲ]?

387
00:19:38,729 --> 00:19:39,604
ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]

388
00:19:39,604 --> 00:19:45,880

389
00:19:45,880 --> 00:19:46,400
>> ಹೌದು.

390
00:19:46,400 --> 00:19:51,550
ಆದ್ದರಿಂದ ರಚನೆಯ ಕೇವಲ ನಾಲ್ಕು ಸ್ಥಳಗಳನ್ನು ಹೊಂದಿದೆ,
ಇದು 3 ಮೂಲಕ ಸೂಚ್ಯಂಕಗಳು 0 ಅರ್ಥ.

391
00:19:51,550 --> 00:19:55,630
ಈ ಸಂದರ್ಭದಲ್ಲಿ ವೇಳೆ, ನಾನು ಆದ್ದರಿಂದ
ಹಂತದಲ್ಲಿ ಮೌಲ್ಯ 4 ತೆಗೆದುಕೊಳ್ಳುತ್ತವೆ.

392
00:19:55,630 --> 00:20:00,910
ವಯೋವರ್ಗದಲ್ಲಿನ 4 ಸ್ಥಾಪನೆಗೆ ನಡೆಯಲಿದೆ
ಯಾವುದೇ ಇಲ್ಲಿ ನಡೆಯುತ್ತದೆ

393
00:20:00,910 --> 00:20:02,920
ನಾನು ಹೇಳಲು ಏನು, 6 ನಮೂದಿಸಿ.

394
00:20:02,920 --> 00:20:05,010
6 ಈ ಸೆಟ್ಟಿಂಗ್ ಮಾಡುತ್ತೇವೆ.

395
00:20:05,010 --> 00:20:06,560
>> ಆದರೆ ನಾವು ಇಲ್ಲಿ ಮುಗಿಯುವ ಏನು ಗೊತ್ತಿಲ್ಲ.

396
00:20:06,560 --> 00:20:08,836
ಈ ಮೆಮೊರಿ ಅಲ್ಲ
ನಾವು ಪ್ರವೇಶಿಸಲು ಹೊಂದಿತ್ತು.

397
00:20:08,836 --> 00:20:10,710
ಆದ್ದರಿಂದ ನೀವು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ
ಹಿಂದಿನ ಉಪನ್ಯಾಸ,

398
00:20:10,710 --> 00:20:14,350
ಅವರು Zamyla ಮೌಲ್ಯಗಳನ್ನು ಮುದ್ರಿಸುವ ಮತ್ತು
ಹಂತದಲ್ಲಿ ಅವರು ಈ ವಿಭಜನೆ ಹಿಟ್

399
00:20:14,350 --> 00:20:17,990
ತಪ್ಪು. ಆದ್ದರಿಂದ ನೀವು ಬಹುಶಃ ಮಾಡಲಿದ್ದೇನೆ
ನೀವು ಅನೇಕ ವಿಭಜನೆ ದೋಷಗಳು

400
00:20:17,990 --> 00:20:20,530
ಸಮಸ್ಯೆ ಸೆಟ್ ಕೆಲವು ಬಳಸಿಕೊಂಡು.

401
00:20:20,530 --> 00:20:24,950
ಆದರೆ ಈ ಮಾರ್ಗಗಳಲ್ಲಿ ಒಂದು ಇದರಲ್ಲಿ
ನೀವು ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ಎದುರಿಸುವ

402
00:20:24,950 --> 00:20:28,540
ನೀವು ಪ್ರವೇಶಿಸುವ ಪ್ರಾರಂಭಿಸಿದಾಗ, ತಪ್ಪು
ನೀವು ಮಾಡಬಾರದು ಎಂದು ರೀತಿಯಲ್ಲಿ ಮೆಮೊರಿ.

403
00:20:28,540 --> 00:20:34,117
ನಾವು ಪ್ರವೇಶವನ್ನು ಹೊಂದಿಲ್ಲ
ಈ ಸ್ಥಳ ಮತ್ತು ಈ ಒಂದು ದೋಷವನ್ನು ಹೊಂದಿದೆ.

404
00:20:34,117 --> 00:20:37,760

405
00:20:37,760 --> 00:20:40,190
>> ಆದ್ದರಿಂದ ಈ ಉತ್ತಮ.

406
00:20:40,190 --> 00:20:45,820
ಈಗ ಇನ್ನೂ ಒಂದು ಸಣ್ಣ ಇಲ್ಲ
ಈ ಕೋಡ್ ಸಮಸ್ಯೆ.

407
00:20:45,820 --> 00:20:50,720
ಮತ್ತು ನಾವು ನೀವು ಮೂಲತಃ
ಇನ್ನೂ ನಾಲ್ಕು ವಿದ್ಯಾರ್ಥಿಗಳು ಅಂಟಿಕೊಂಡಿತು.

408
00:20:50,720 --> 00:20:52,940
ಈಗ ನಾನು ಸರಿ, ಎಂಟು ವಿದ್ಯಾರ್ಥಿಗಳು ಬಳಸಲು ಬಯಸಿದರೆ.

409
00:20:52,940 --> 00:20:54,350
ಇದು ದೊಡ್ಡ ಒಪ್ಪಂದ ಅಲ್ಲ.

410
00:20:54,350 --> 00:20:58,120
ನಾನು ಬದಲಾಯಿಸಲು, ಹೋಗಬಹುದು
ಕಾಮೆಂಟ್, ಮತ್ತು ಎನ್ ಬದಲಾಯಿಸಲು.

411
00:20:58,120 --> 00:20:59,760
ಈಗ ಈ ಎಂಟು ವಿದ್ಯಾರ್ಥಿಗಳು ಕೆಲಸ ಮಾಡುತ್ತದೆ.

412
00:20:59,760 --> 00:21:02,190
ನಾನು ಈ ಸಂಕಲಿಸಲು ಮತ್ತು ರನ್ ವೇಳೆ
ಈ, ಇದು ನನಗೆ ತೋರಿಸುತ್ತದೆ

413
00:21:02,190 --> 00:21:07,870
ಇದು ಎಂಟು ಪೂರ್ಣಾಂಕಗಳ ವಿನಂತಿಸುತ್ತದೆ
ವಿದ್ಯಾರ್ಥಿಗಳು ಮತ್ತು ಇದು ಕೆಲಸ ಮಾಡುತ್ತದೆ.

414
00:21:07,870 --> 00:21:11,850
ಆದರೆ ಅಗತ್ಯ ಆದರ್ಶ ಕಡಿಮೆ
ಕಾರ್ಯಕ್ರಮದ ಪ್ರತಿಯೊಂದು ಬಾರಿ ಮರುಸಂಕಲಿಕೆಯು

415
00:21:11,850 --> 00:21:15,960
ನಾನು ವಿದ್ಯಾರ್ಥಿಗಳ ಸಂಖ್ಯೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ
ನಾನು ವಯಸ್ಸಿನ ಪ್ರವೇಶಿಸಲು ಬಯಸುವ.

416
00:21:15,960 --> 00:21:22,990
>> ಆದ್ದರಿಂದ ಅಂತಿಮ ಸುಧಾರಣೆಗಾಗಿ
ನಾವು ಇಲ್ಲಿ ನೋಡುತ್ತಾರೆ ಎಂದು ಈ, ನಾವು ಆರ್

417
00:21:22,990 --> 00:21:26,177
ಜನರ ಸಂಖ್ಯೆ ವಿನಂತಿಸಲು ಹೋಗಿ.

418
00:21:26,177 --> 00:21:28,010
ಇಲ್ಲಿ ನಾವು ಹೊಂದಿದ್ದೇವೆ
ಕೊಠಡಿಗಳಲ್ಲಿ ಜನರ

419
00:21:28,010 --> 00:21:29,880
ಅಥವಾ ಕೋಣೆಯಲ್ಲಿ ಜನರು ಯಾವುದೇ ವಯಸ್ಸಿನ.

420
00:21:29,880 --> 00:21:33,300
ಆದರೆ ನಾವು ಸಂಖ್ಯೆ ಮನವಿ ನೀನು
ಬಳಕೆದಾರರಿಂದ ಕೋಣೆಯಲ್ಲಿ ಜನರು.

421
00:21:33,300 --> 00:21:36,171
ಆದ್ದರಿಂದ ಈ ಅದೇ ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಆಗಿದೆ
ನಾವು ಮೊದಲು ನೋಡಿದ ಲೂಪ್.

422
00:21:36,171 --> 00:21:37,920
ಇದು ಅದೇ ಇಲ್ಲಿದೆ
ಹಾಗೆ-ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಎಂದು ನೀವು

423
00:21:37,920 --> 00:21:40,050
ಸಮಸ್ಯೆ ಸೆಟ್ ಮೇಲೆ ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡಬಹುದು.

424
00:21:40,050 --> 00:21:43,102
ಆದ್ದರಿಂದ ಹೊತ್ತು ಮಾಡಿದಾಗ
1 ಹೆಚ್ಚು N ಕಡಿಮೆ ಪ್ರವೇಶಿಸುವ,

425
00:21:43,102 --> 00:21:45,310
ಆದ್ದರಿಂದ ಇರುವಂತೆ ಅವರಲ್ಲಿದೆ
ಕೋಣೆಯಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು ವ್ಯಕ್ತಿ.

426
00:21:45,310 --> 00:21:47,407
ಹೊತ್ತು ಮಾಡಿದಾಗ
1 ಹೆಚ್ಚು N ಕಡಿಮೆ ಪ್ರವೇಶಿಸುವ,

427
00:21:47,407 --> 00:21:48,990
ನಂತರ ನಾವು ಮತ್ತೆ ಕೇಳುವ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು.

428
00:21:48,990 --> 00:21:50,906
ಸಂಖ್ಯೆ ನಮೂದಿಸಿ
ಕೋಣೆಯಲ್ಲಿ ಜನರು.

429
00:21:50,906 --> 00:21:53,550
ಈಗ, ಒಮ್ಮೆ ನಾವು ಹೊಂದಿದ್ದೇವೆ
room-- ಜನರ

430
00:21:53,550 --> 00:21:58,020
ಆದ್ದರಿಂದ ನಾನು ಆ ನಮೂದಿಸಿ ಇರಬಹುದು
ಈ ಕೋಣೆಯಲ್ಲಿ 200 ಜನರು.

431
00:21:58,020 --> 00:22:05,480
ನಂತರ ಇಲ್ಲಿ ಕೆಳಗೆ ನಾವು ಬರಲು ನೀನು
ಮತ್ತು ಗಾತ್ರ 200 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು.

432
00:22:05,480 --> 00:22:10,220
ನಾವು ಎಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ
ದೊಡ್ಡ ಸಾಕಷ್ಟು 200 ವಯಸ್ಸಿನ ಹಿಡಿದಿಡಲು.

433
00:22:10,220 --> 00:22:15,370
ಕೆಳಗೆ ಬರುವ, ಇದು ಲೂಪ್ ಇಲ್ಲಿದೆ
ನೀವು ಬಹಳ ಬಳಸಲಾಗುತ್ತದೆ ಎಂದು.

434
00:22:15,370 --> 00:22:19,490
ಆದ್ದರಿಂದ ಈ ರಚನೆಯ ಮೇಲೆ iterating,
ಪ್ರತಿ ಸ್ಥಳ ನಿಯೋಜಿಸುವ

435
00:22:19,490 --> 00:22:23,020
ಆ ಶ್ರೇಣಿಯಲ್ಲಿನ ಒಂದು ಪೂರ್ಣಾಂಕ, ಮತ್ತು
ನಂತರ ಅಂತಿಮವಾಗಿ ಇಲ್ಲಿ ನಾವು ಆರ್

436
00:22:23,020 --> 00:22:28,340
ಕೇವಲ iterating ಉದಾಹರಣೆ ಪಡೆಯುವಲ್ಲಿ
ರಚನೆಯ ಮೇಲೆ, ಮೌಲ್ಯಗಳನ್ನು ನಿಗದಿ ಅಲ್ಲ,

437
00:22:28,340 --> 00:22:30,150
ಆದರೆ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರವೇಶಿಸಲು.

438
00:22:30,150 --> 00:22:33,810
>> ಇಲ್ಲಿ ನಾವು ನೋಡಿ ನಾವು
ಈಗ ಒಂದು ವರ್ಷದ, ಹೇಳುತ್ತಿದ್ದಾರೆ,

439
00:22:33,810 --> 00:22:40,470
ವ್ಯಕ್ತಿ% ನಾನು ವರ್ಷ% ಆಗಿರುತ್ತದೆ
ಮೊದಲ% ನಾನು ಜೊತೆಗೆ 1 ಅಲ್ಲಿ.

440
00:22:40,470 --> 00:22:43,010
ಆದ್ದರಿಂದ ನಾನು ಈ ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ಅಸ್ಥಿರವಾಗಿದೆ.

441
00:22:43,010 --> 00:22:49,420
ಮತ್ತು ಎರಡನೇ% ನಾನು ಎಂದು ನಾನು
ವಯಸ್ಸಿನ ರಚನೆಯ ಜೊತೆಗೆ 1 ಸಂಗ್ರಹವಾಗಿರುವ ಮೌಲ್ಯವು.

442
00:22:49,420 --> 00:22:54,217
ಆದ್ದರಿಂದ ಈ ಜೊತೆಗೆ 1 ನಾವು ನೀವು ಕೇವಲ ಆಗಿದೆ
ಈ ಜೊತೆಗೆ 1 saying-- ವಯಸ್ಸಿನ ನಾನು ಜೊತೆಗೆ 1.

443
00:22:54,217 --> 00:22:57,050
ಈ ಜೊತೆಗೆ 1 ನಾವು ನೀವು ಕೇವಲ ಆಗಿದೆ
ಈಗ ವ್ಯಕ್ತಿಯಿಂದ ವರ್ಷಕ್ಕೆ ಹೇಳುವ

444
00:22:57,050 --> 00:22:58,280
ಈ ಹಳೆಯ ಇರುತ್ತದೆ.

445
00:22:58,280 --> 00:23:01,080
>> ಹಾಗಿರುವಾಗ ಈ ನಾನು ಜೊತೆಗೆ 1?

446
00:23:01,080 --> 00:23:04,064
ನಾವು ಅಲ್ಲಿ ಒಂದು ಪ್ಲಸ್ 1 ಹೊಂದಿವೆ?

447
00:23:04,064 --> 00:23:04,564
ಹೌದು.

448
00:23:04,564 --> 00:23:07,410

449
00:23:07,410 --> 00:23:07,930
ಹೌದು.

450
00:23:07,930 --> 00:23:10,510
ಆದ್ದರಿಂದ ಸರಣಿಗಳ ಶೂನ್ಯ ಸೂಚ್ಯಂಕದೊಡನೆ ನೆನಪಿಡಿ.

451
00:23:10,510 --> 00:23:14,840
ನಾವು ಈ ಮುದ್ರಿಸುವ ಆದ್ದರಿಂದ
ಯಾರಾದರೂ ಕೇವಲ ಔಟ್ಪುಟ್ ಓದಲು,

452
00:23:14,840 --> 00:23:19,380
ನಂತರ ಬಹುಶಃ ಅವರು ಏನೋ ನೋಡಲು ಬಯಸುವ
ವ್ಯಕ್ತಿ ಒಂದು ವ್ಯಕ್ತಿ ಸಂಖ್ಯೆ ಒಂದು ರೀತಿಯ,

453
00:23:19,380 --> 00:23:21,160
20 ವರ್ಷ ಇರುತ್ತದೆ.

454
00:23:21,160 --> 00:23:23,570
ವ್ಯಕ್ತಿ ಎರಡನೆಯದಾಗಿ 15 ವರ್ಷ ಇರುತ್ತದೆ.

455
00:23:23,570 --> 00:23:27,420
ಅವರು ಹೆಚ್ಚಾಗಿ ವ್ಯಕ್ತಿ ನೋಡಿ 'd
ಸಂಖ್ಯೆ ಶೂನ್ಯ 15 ವರ್ಷ ವಯಸ್ಸು.

456
00:23:27,420 --> 00:23:36,460
>> ಆದ್ದರಿಂದ ಈ ಕಂಪೈಲ್ ಮತ್ತು ಕೇವಲ ನೋಡಿದ ಏನು
ಇದು ಕೆಲವು ಜಾಗವನ್ನು ರಚಿಸಿ ಹಾಗೆ ಕಾಣುತ್ತದೆ.

457
00:23:36,460 --> 00:23:43,560
ವಯಸ್ಸಿನ ಸಂಗ್ರಹಿಸುತ್ತಾ ಮಾಡಿ.

458
00:23:43,560 --> 00:23:45,080
ವಯಸ್ಸಿನ ರನ್ನಿಂಗ್.

459
00:23:45,080 --> 00:23:46,580
ನಾವು ಕೋಣೆಯಲ್ಲಿ ಜನರ ಸಂಖ್ಯೆ ನೋಡಿ.

460
00:23:46,580 --> 00:23:48,850
ಹಾಗಾಗಿ ಇವೆ ಹೇಳುತ್ತೇನೆ
ಕೋಣೆಯಲ್ಲಿ ಮೂರು ಜನರು.

461
00:23:48,850 --> 00:23:54,000
ವ್ಯಕ್ತಿ ಒಂದನೇ ವಯಸ್ಸು,
15, 20, 25 ಸೇ.

462
00:23:54,000 --> 00:23:59,680
ಮತ್ತು ಈಗ ನಾನು ವರ್ಷದಿಂದ ಹೇಳುತ್ತೇನೆ
ಈಗ ಅವರು 16, 21, 26 ಇರುತ್ತದೆ.

463
00:23:59,680 --> 00:24:02,900
ಈ ಕೆಲಸ ಎಂದು ನೋಡೋಣ
3 ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ಎನ್.

464
00:24:02,900 --> 00:24:07,940
ಹಾಗಾಗಿ, ಜನರ ಸಂಖ್ಯೆ, ಒಂದು 5 ಹೇಳುತ್ತಾರೆ
ಎರಡು, ಮೂರು, ಎರಡು, ಒಂದು, ಈಗ ಒಂದು ವರ್ಷ

465
00:24:07,940 --> 00:24:11,170
ಅವರು, ಎರಡು, ಮೂರು ಎಂದು ಮಾಡುತ್ತೇವೆ
ನಾಲ್ಕು, ಮೂರು, ಎರಡು ವರ್ಷ.

466
00:24:11,170 --> 00:24:16,500
ಆದ್ದರಿಂದ ನಾನು ಸಾಧ್ಯವೋ
ಸುಲಭವಾಗಿ ಎನ್ 10,000 ಇರಬೇಕು ಎಂದು.

467
00:24:16,500 --> 00:24:21,270
ಈಗ ನಾನು ಸಾಕಷ್ಟು ಇಲ್ಲಿ ಕುಳಿತು ಮಾಡಲಾಗುತ್ತದೆ
ಸದ್ಯಕ್ಕೆ ವಯಸ್ಸಿನ ಪ್ರವೇಶಿಸುವ, ಆದರೆ ಈ ಕೆಲಸ.

468
00:24:21,270 --> 00:24:26,000
>> ಈಗ ಮೆಮೊರಿ ಎಲ್ಲೋ ನಾವು
, ಗಾತ್ರ 10,000 ಒಂದು ಸರಣಿ

469
00:24:26,000 --> 00:24:28,830
ಅಂತಿಮವಾಗಿ 40,000
ಬೈಟ್ಗಳು, ಇರುವುದರಿಂದ

470
00:24:28,830 --> 00:24:31,222
ಆ ಪೂರ್ಣಾಂಕಗಳ ಪ್ರತಿಯೊಂದು ನಾಲ್ಕು ಬೈಟ್ಗಳು.

471
00:24:31,222 --> 00:24:33,180
ಆದ್ದರಿಂದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಇಲ್ಲ
ಗಾತ್ರ 10,000 ಅಲ್ಲಿ ನಾವು

472
00:24:33,180 --> 00:24:36,201
ಆ 10,000 ಜನರ ವಯಸ್ಸಿನ ಶೇಖರಿಸಿಡಲು.

473
00:24:36,201 --> 00:24:36,700
ಆಯ್ತು.

474
00:24:36,700 --> 00:24:40,070
ಈ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

475
00:24:40,070 --> 00:24:41,892
ಹೌದು.

476
00:24:41,892 --> 00:24:43,350
ಏನು ನೀವು ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ ನೀಡಿದರೆ?

477
00:24:43,350 --> 00:24:44,870
ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

478
00:24:44,870 --> 00:24:49,320
ಈ ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಖ್ಯೆಯಲ್ಲಿ ಆದ್ದರಿಂದ
ಕೊಠಡಿ, ಋಣಾತ್ಮಕ ಜನರು.

479
00:24:49,320 --> 00:24:52,580
ಅದು ನಿರಾಕರಿಸಿತು
ಇಲ್ಲಿ ನಾವು ಸಂಭವಿಸಿ ಏಕೆಂದರೆ

480
00:24:52,580 --> 00:24:57,180
n ವೇಳೆ ವಾಸ್ತವವಾಗಿ ನಿರ್ವಹಣೆ ಎಂದು
ಕಡಿಮೆ ಒಂದು ನಾವು ಮತ್ತೆ ಕೇಳಲು ನೀನು.

481
00:24:57,180 --> 00:25:01,780
ನೀವು ಘೋಷಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ
ಋಣಾತ್ಮಕ ಗಾತ್ರದ ರಚನೆಯ

482
00:25:01,780 --> 00:25:03,950
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.

483
00:25:03,950 --> 00:25:05,570
>> ಆದ್ದರಿಂದ ನ ಪ್ರಯತ್ನಿಸೋಣ.

484
00:25:05,570 --> 00:25:08,000
ನ ನಿರ್ಲಕ್ಷಿಸಿ ಯಾವುದೇ
ಎನ್ ಮೌಲ್ಯವನ್ನು ಅವರು ಇನ್ಪುಟ್

485
00:25:08,000 --> 00:25:10,571
ಮತ್ತು ಕೇವಲ ಇಂಟ್ ವಯಸ್ಸಿನ ಋಣಾತ್ಮಕ ಒಂದು ಹೇಳುತ್ತಾರೆ.

486
00:25:10,571 --> 00:25:12,410
ಇದು ಸಂಗ್ರಹಿಸುತ್ತಾ ನೋಡೋಣ.

487
00:25:12,410 --> 00:25:14,100
ನಾನು ಖಚಿತವಾಗಿ ಇಲ್ಲ.

488
00:25:14,100 --> 00:25:14,920
ನಂ

489
00:25:14,920 --> 00:25:18,280
ಆದ್ದರಿಂದ ವಯಸ್ಸಿನ ಒಂದು ಎಂದು ಘೋಷಿಸಲಾಗುವುದು
ನಕಾರಾತ್ಮಕ ಗಾತ್ರದೊಂದಿಗೆ ಶ್ರೇಣಿಯನ್ನು.

490
00:25:18,280 --> 00:25:22,540
ಆದ್ದರಿಂದ ಮೊದಲೇ ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸಾಧ್ಯವಿಲ್ಲ ಗುರುತಿಸುತ್ತದೆ
ನಕಾರಾತ್ಮಕ ಚೌಕಟ್ಟಿಗೆ ಒಳಪಟ್ಟಿರಬೇಕು ಮತ್ತು ತಿರಸ್ಕರಿಸುತ್ತದೆ.

491
00:25:22,540 --> 00:25:26,840
ಈಗ, ನಾವು ನಿರ್ವಹಿಸಲು ಮಾಡದಿದ್ದಲ್ಲಿ
ಈ ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಸರಿಯಾಗಿ,

492
00:25:26,840 --> 00:25:28,810
ನಾವು ತಪಾಸಣೆ ವೇಳೆ
N ಕಡಿಮೆ 1 ಹೊಂದಿವೆ ವೇಳೆ

493
00:25:28,810 --> 00:25:32,690
ಈಗಷ್ಟೇ ಹೇಳಲು ಅವಕಾಶ
ಎಲ್ಲಾ ಈ ಹೊಂದಿರಲಿಲ್ಲ

494
00:25:32,690 --> 00:25:35,940
ಮತ್ತು ಬದಲಿಗೆ ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕ ದೋಚಿದ.

495
00:25:35,940 --> 00:25:40,710
ಯಾವುದೇ ಪೂರ್ಣಾಂಕ ಎಂಥದ್ದು
ನಾವು ಆ ಗಾತ್ರದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು.

496
00:25:40,710 --> 00:25:44,250
>> ಆದ್ದರಿಂದ ಕಂಪೈಲರ್ ಸಾಧ್ಯವಿಲ್ಲ
ಬಹುಶಃ ಈಗ ದೂರು.

497
00:25:44,250 --> 00:25:48,780
ನಾನು this-- ಕಂಪೈಲ್
ಆದ್ದರಿಂದ ದೂರು ಸಾಧ್ಯವಿಲ್ಲ,

498
00:25:48,780 --> 00:25:51,480
ಇದು ನಾನು ಮನುಷ್ಯ ಎಂದು ತಿಳಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ
ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆ ನಮೂದಿಸಿ ಹೋಗುವ,

499
00:25:51,480 --> 00:25:52,550
ಇದು ಅಮಾನ್ಯವಾದ ಇರಬಹುದು.

500
00:25:52,550 --> 00:25:54,633
ಎಲ್ಲಾ ಇದು ನಾನು ಬಹುಶಃ, ತಿಳಿದಿರುವ
ಧನಾತ್ಮಕ ಸಂಖ್ಯೆ ನಮೂದಿಸಿ,

501
00:25:54,633 --> 00:25:56,000
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಮಾನ್ಯವಾಗಿಲ್ಲ.

502
00:25:56,000 --> 00:26:01,090
ನಾನು 1 ಋಣಾತ್ಮಕ ನಮೂದಿಸಿ ಆದ್ದರಿಂದ ನಾನು ಊಹಿಸಿಕೊಳ್ಳಲು
ಕೋಣೆಯಲ್ಲಿ ಜನರು, ತಪ್ಪು ವಿಭಜನೆ.

503
00:26:01,090 --> 00:26:06,040
>> ಆದ್ದರಿಂದ, ಸರಿ.

504
00:26:06,040 --> 00:26:13,160
ಆದ್ದರಿಂದ ಅವರ ಈ ಮತ್ತೆ ಸೇರಿಸಲು ಅವಕಾಶ
ಅದು ಮೂಲತಃ ಯಾವ ನೋಡಿಕೊಳ್ಳಿ.

505
00:26:13,160 --> 00:26:15,640
ಆದ್ದರಿಂದ ವಯಸ್ಸಿನ ಮಾಡಲು.

506
00:26:15,640 --> 00:26:18,120
ಈಗ ನಾನು ಪ್ರಯತ್ನಿಸಿ ಬಯಸಿದರೆ
ಋಣಾತ್ಮಕ ಆದ್ದರಿಂದ ಹೊರಡೋಣ age--

507
00:26:18,120 --> 00:26:19,710
ಕೋಣೆಯಲ್ಲಿ ಐದು ಜನರಿರುತ್ತಾರೆ ಹೇಳುತ್ತಾರೆ.

508
00:26:19,710 --> 00:26:23,180
ವ್ಯಕ್ತಿ ಒಂದನೇ ವಯಸ್ಸು
, ವ್ಯಕ್ತಿ ಮೂರು ನಕಾರಾತ್ಮಕ 4

509
00:26:23,180 --> 00:26:26,500
ಶೂನ್ಯ, ವ್ಯಕ್ತಿ ಸರಿ three-- ಆಗಿದೆ.

510
00:26:26,500 --> 00:26:29,850
ಇಲ್ಲಿ, ಒಂದು ವರ್ಷ ಇಂದಿನಿಂದ, ವ್ಯಕ್ತಿ ಸಂಖ್ಯೆ
ಒಂದು 3 ವರ್ಷ ಋಣಾತ್ಮಕ ಇರುತ್ತದೆ.

511
00:26:29,850 --> 00:26:32,830
ಆದ್ದರಿಂದ ಬಹುಶಃ ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

512
00:26:32,830 --> 00:26:37,220
ಆದರೆ ಕೇವಲ ಕಾಣುವ ಕಾರಣ
ಕೋಡ್ ಎಲ್ಲಾ ನಾವು ಮಾಡುತ್ತಿರುವುದು

513
00:26:37,220 --> 00:26:40,260
GetInt ವಿನಂತಿಸುತ್ತಿದೆ.

514
00:26:40,260 --> 00:26:44,110
>> ಈಗ, ನಾವು ಹೊಂದಿತ್ತು ವೇಳೆ
GetPositiveInt ಕಾರ್ಯ

515
00:26:44,110 --> 00:26:49,690
ಅಥವಾ ನಾವು ಸರಳವಾಗಿ ಈ ಮಾಡಿದ್ದು
ಕೆಳಗೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ರೀತಿಯ,

516
00:26:49,690 --> 00:26:52,340
ಈ ನಿಖರವಾಗಿ ಉತ್ತಮ ಕೆಲಸ ಎಂದು.

517
00:26:52,340 --> 00:26:54,200
ಆದರೆ ಈ ನಿರ್ದಿಷ್ಟವಾಗಿ
ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಇಲ್ಲ

518
00:26:54,200 --> 00:26:57,772
ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ನಿಭಾಯಿಸಲು ಎಂದು ಸಂಭವಿಸಿ.

519
00:26:57,772 --> 00:26:59,147
ರಚನೆಗಳು ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

520
00:26:59,147 --> 00:27:02,290

521
00:27:02,290 --> 00:27:03,250
ಸರಿ.

522
00:27:03,250 --> 00:27:09,380
>> ನಾವು ಈಗ ರಚನೆಗಳು ನೋಡಿದ.

523
00:27:09,380 --> 00:27:12,500
ನಾವು ಬಳಸಬೇಕಾಗುತ್ತದೆ ನೀನು
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಈ.

524
00:27:12,500 --> 00:27:14,680
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ two-- ಸೆಟ್
ನಾನು ಅನೇಕ ಗೊತ್ತು

525
00:27:14,680 --> 00:27:18,040
ಇನ್ನೂ ಸಮಸ್ಯೆ ಸೆಟ್ ಕೆಲಸ ಮಾಡಬಹುದು
ಒಂದು, ಆದರೆ ಸಮಸ್ಯೆ ಎರಡು ಮೇಲೇಳುತ್ತಿರುವ ಇದೆ ಸೆಟ್.

526
00:27:18,040 --> 00:27:22,260
ಸಮಸ್ಯೆಯನ್ನು ಎರಡು ಸೆಟ್, ನೀವು ನೀನು
ತಂತಿಗಳು, ಸಾಲುಗಳು ವ್ಯವಹರಿಸುವಾಗ ಅಗತ್ಯವಿದೆ,

527
00:27:22,260 --> 00:27:23,950
ಮತ್ತು ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

528
00:27:23,950 --> 00:27:26,270
>> ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಯಾವುವು?

529
00:27:26,270 --> 00:27:29,570
ಈಗ, ನೀವು ಇಲ್ಲಿ ಕೆಳಗೆ ನೋಡಬಹುದು
ನಿಖರವಾಗಿ ಕಡಿಮೆ ಟೀಸರ್

530
00:27:29,570 --> 00:27:30,950
ಹೋಗುವ ನಡೆಯುತ್ತಿದೆ.

531
00:27:30,950 --> 00:27:32,950
ನಾವು, ಇಂಟ್ ಮುಖ್ಯ, Inc argc ನೋಡಿ
ಸ್ಟ್ರಿಂಗ್ argv ಬ್ರಾಕೆಟ್ಗಳನ್ನು.

532
00:27:32,950 --> 00:27:34,560

533
00:27:34,560 --> 00:27:38,130
ಆದ್ದರಿಂದ ಮೊದಲ ನ ಅರ್ಥೈಸಲು ಪ್ರಯತ್ನಿಸೋಣ
ಏನು ಎಂದು ಹೇಳಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದಾರೆ.

534
00:27:38,130 --> 00:27:40,800
ಸರಿ, ಈಗ.

535
00:27:40,800 --> 00:27:44,637
>> ಆದ್ದರಿಂದ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ನೀವು ಇರಬೇಕು
ಈ ಆಜ್ಞೆಗಳನ್ನು ಕೆಲವು ಬಳಸಲಾಗುತ್ತದೆ ಸಿಲುಕುವ

536
00:27:44,637 --> 00:27:48,580
ಈಗ, ಮತ್ತು ನೀವು ಬಹುಶಃ ಹೊಸದೊಂದು
ಮೊದಲು ಟರ್ಮಿನಲ್ ಸಿಡಿ.

537
00:27:48,580 --> 00:27:52,100
ನಾವು ಸಿಡಿ pset1 ಹೇಳಲು ವೇಳೆ,
ನೀವು ಎಂದು ತಿಳಿಯಲು

538
00:27:52,100 --> 00:27:55,050
pset1 ಕೋಶಕ್ಕೆ ಬದಲಾವಣೆ.

539
00:27:55,050 --> 00:27:59,120
>> ಈಗ ನೀವು ಎಂದಿಗೂ ಬಂದಿದೆ ಗಮನಕ್ಕೆ
ಮೊದಲು ಈ ರೀತಿಯ ಪ್ರೊಗ್ರಾಮ್.

540
00:27:59,120 --> 00:28:03,120
ನೀವು ಬರೆದ ಎಂಬುದನ್ನು ಪ್ರತಿ ಪ್ರೋಗ್ರಾಂ
ನೀವು ಹೇಳುವ, ಓಡುತ್ತವೆ ಮಾರಿಯೋ ಡಾಟ್ ಕತ್ತರಿಸಿ,

541
00:28:03,120 --> 00:28:06,779
ಡಾಟ್ ದುರಾಸೆಯ ಕಡಿದು, ಮತ್ತು ನಂತರ ಅದನ್ನು
ಇನ್ಪುಟ್ ನಿಮ್ಮನ್ನು ಕೇಳಬಹುದು.

542
00:28:06,779 --> 00:28:08,570
ಈಗ, ಆ ಅಲ್ಲ ಇಲ್ಲಿದೆ
ಕೋಶವನ್ನು ಬದಲಾಯಿಸಲು ಮಾಡುತ್ತದೆ.

543
00:28:08,570 --> 00:28:12,770
ನೀವು CD ಔಟ್ ಅದು ನಂತರ, ಹೇಳಲು ಇಲ್ಲ
ನೀವು CD ಗೆ ಇದು ಕೋಶಕ್ಕೆ ಬಯಸುತ್ತೀರಿ?

544
00:28:12,770 --> 00:28:17,200
ಬದಲಿಗೆ, ನೀವು ಹೇಳಲು, ಸಿಡಿ pset1, ಮತ್ತು
ಇದು ಕೇವಲ pset1 ಕೋಶಕ್ಕೆ ಹೋಗುತ್ತದೆ.

545
00:28:17,200 --> 00:28:20,430
>> ಆದ್ದರಿಂದ ಅದೇ ನಾವು ಇತರ ಉದಾಹರಣೆಗಳು.

546
00:28:20,430 --> 00:28:21,540
ನಿನ್ನ ಮಾಡಲು.

547
00:28:21,540 --> 00:28:25,760
ನೀವು ಮಾಡಲು ಔಟ್ ಮಾಡಿದಾಗ, ಇದು ನಂತರ, ಹೇಳಲು ಇಲ್ಲ
ಪ್ರೋಗ್ರಾಂ ನೀವು ಮಾಡಲು ಬಯಸುತ್ತೀರಿ?

548
00:28:25,760 --> 00:28:29,620
ನೀವು, ಹೇಳುತ್ತಾರೆ
ಆಜ್ಞಾ ಸಾಲಿನ ನಿನ್ನ ಮಾಡಲು.

549
00:28:29,620 --> 00:28:31,060
>> ಮೂವ್ ಇನ್ನೊಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

550
00:28:31,060 --> 00:28:34,840
ನಾವು ಚಲಿಸುತ್ತಿರುವಾಗ ಈ ಒಂದು
ಒಂದು ಕೋಶವನ್ನು ಅಪ್ ಫೈಲ್ mario.c.

551
00:28:34,840 --> 00:28:38,060
ಈಗ ನಾವು ಈ ಉದಾಹರಣೆಗೆ ಗೊತ್ತು
ನಾವು ಎರಡು ವಾದಗಳು ಹಾದುಹೋಗುವ ನೀವು.

552
00:28:38,060 --> 00:28:42,090
ಮೊದಲ ಚರ್ಚೆಯಂತೆ mario.c ಇಲ್ಲ,
ಮತ್ತು ಡಾಟ್ ಡಾಟ್ ಎರಡನೇ ವಾದವು.

553
00:28:42,090 --> 00:28:46,140
ತದನಂತರ ನೀವು, ನೀವು ಮಾಡಲು ರನ್
ನಿಜಕ್ಕೂ ದೀರ್ಘ ಆಜ್ಞೆಯನ್ನು ನೋಡಿ ಸಾಲು

554
00:28:46,140 --> 00:28:50,580
ನಿಜಕ್ಕೂ ದೀರ್ಘ ಆಜ್ಞೆಯನ್ನು
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಮುದ್ರಿತ.

555
00:28:50,580 --> 00:28:53,590
ಆದ್ದರಿಂದ ದೀರ್ಘ ಈ ಆಜ್ಞೆ
ಇದು ಅಲ್ಪ ಭಾಗವಾಗಿದೆ,

556
00:28:53,590 --> 00:28:56,090
ಆದರೆ ಈಗ ನಾವು ಮೂರು ಹೊಂದಿವೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

557
00:28:56,090 --> 00:28:59,750
ಡಾಟ್ ಡ್ಯಾಶ್ ಶೂನ್ಯ, ಹಲೋ, ಮತ್ತು hello.c.

558
00:28:59,750 --> 00:29:03,497
>> ಆದ್ದರಿಂದ ಈ ಆಜ್ಞಾ ಸಾಲಿನ ಇವೆ
ವಾದಗಳು, ವಾದಗಳು

559
00:29:03,497 --> 00:29:05,580
ನೀವು ಹಾದುಹೋಗುವ ನೀವು
ಆಜ್ಞಾ ಸಾಲಿನ ಆದ್ದರಿಂದ

560
00:29:05,580 --> 00:29:08,680
ಸೂಚಿಸಲಾಗುವುದು ಹೊಂದಿಲ್ಲ
ನೀವು ಪ್ರೋಗ್ರಾಂ.

561
00:29:08,680 --> 00:29:13,090
ಇದು ಹುಟ್ಟಿಸಿದ ಎಂದು, ವೇಳೆ
ನೀವು ಖಣಿಲು ನಡೆಸುತ್ತಿದ್ದರು ಇದು, ಸರಿ ", ಹೇಳಿದರು

562
00:29:13,090 --> 00:29:15,630
ಪ್ರೋಗ್ರಾಂ ಇದು ಇದು
ಫೈಲ್ ಕಂಪೈಲ್?

563
00:29:15,630 --> 00:29:17,010
Hello.c.

564
00:29:17,010 --> 00:29:19,440
ಏನು ಧ್ವಜಗಳು ನೀವು ಬಯಸುವ
ದಾಖಲಿಸಲು? ಡ್ಯಾಶ್ ಒ.

565
00:29:19,440 --> 00:29:21,190
ಏನು ನೀವು ಬಯಸುತ್ತೀರಿ
ಕಡತ ಎಂದು?

566
00:29:21,190 --> 00:29:21,690
ಹಲೋ.

567
00:29:21,690 --> 00:29:25,290
ಇಲ್ಲ, ನೀವು ಖಣಿಲು ರನ್
ಒ hello.c ಹಲೋ ಡ್ಯಾಶ್.

568
00:29:25,290 --> 00:29:28,820
>> ಆದ್ದರಿಂದ ಮತ್ತೆ ಈ ನೋಡುವ.

569
00:29:28,820 --> 00:29:32,920
ಈಗ argc-- argc ಆರ್ಗ್ಯುಮೆಂಟ್ ಎಣಿಕೆಗಳು ಹೊಂದಿದೆ.

570
00:29:32,920 --> 00:29:36,620
ಇದು ಆಜ್ಞಾ ಸಾಲಿನ ಸಂಖ್ಯೆ ಇಲ್ಲಿದೆ
ವಾದಗಳು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಪ್ರವೇಶಿಸಿತು.

571
00:29:36,620 --> 00:29:39,720
ಅಲ್ಲದೆ, ತಾಂತ್ರಿಕವಾಗಿ argv--
ವಿ, ವೆಕ್ಟರ್ ಎಂದರೆ

572
00:29:39,720 --> 00:29:41,460
ಇದು ಮೂಲತಃ ಶ್ರೇಣಿಯನ್ನು ಅರ್ಥ.

573
00:29:41,460 --> 00:29:42,680
ಆದರೆ ನೀವು ಆ ನಿರ್ಲಕ್ಷಿಸಬಹುದು.

574
00:29:42,680 --> 00:29:47,540
Argv-- ನಾವು, ಸ್ಟ್ರಿಂಗ್ argv ಹೊಂದಿವೆ
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ argv ಬ್ರಾಕೆಟ್ಗಳನ್ನು.

575
00:29:47,540 --> 00:29:50,150
ಆದ್ದರಿಂದ ಈ ಮತ್ತೊಂದು ರೂಪವಾಗಿದೆ
ನೀವು ಮೊದಲು ನೋಡಿಲ್ಲ ಬ್ರಾಕೆಟ್ಗಳನ್ನು.

576
00:29:50,150 --> 00:29:52,300
ನಾವು ನೋಡಿದ ಬ್ರಾಕೆಟ್
ನಾವು ಹೇಳುತ್ತಿದ್ದೆ ಮಾಡಿದಾಗ ಸಂಕೇತ,

577
00:29:52,300 --> 00:29:53,970
ನಂತಹ, ಸ್ಟ್ರಿಂಗ್ ರು Zamyla ಸಮನಾಗಿರುತ್ತದೆ.

578
00:29:53,970 --> 00:29:56,910
ರು ಬ್ರಾಕೆಟ್ 0 ಝೆಡ್ನ ಪ್ರವೇಶ

579
00:29:56,910 --> 00:30:00,720
>> ನಾವು ಆವರಣ ಮಾಡಿದಾಗ ನೋಡಿದ
ನಾವು ಇಂಟ್ ವಯಸ್ಸಿನ 5 ಬ್ರಾಕೆಟ್ ಹೇಳಿದರು.

580
00:30:00,720 --> 00:30:03,160
ಆ ಗಾತ್ರದ 5 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಯಿತು.

581
00:30:03,160 --> 00:30:06,280
ಇಲ್ಲಿ ಒಂದು ಆವೃತ್ತಿಯಾಗಿದೆ
ಆವರಣ ನಾವು ಮೊದಲು ನೋಡಿಯೇ ಇಲ್ಲ.

582
00:30:06,280 --> 00:30:09,630
ಸ್ಟ್ರಿಂಗ್ argv ಆದ್ದರಿಂದ ಈ ರೀತಿಯ
ಸಂಪೂರ್ಣವಾಗಿ ಪರಿಚಿತ ಎಂದು

583
00:30:09,630 --> 00:30:12,050
ಇದು ಕೇವಲ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಎಂದು.

584
00:30:12,050 --> 00:30:14,520
ಈಗ ಆವರಣ ಸೂಚಿಸುತ್ತದೆ
ಈ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.

585
00:30:14,520 --> 00:30:19,920
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ argv ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಸಾಧನವಾಗಿ
ಎಂದು argv ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.

586
00:30:19,920 --> 00:30:22,540
ಈಗ ತಾಂತ್ರಿಕವಾಗಿ ಸ್ಟ್ರಿಂಗ್
ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದೆ.

587
00:30:22,540 --> 00:30:26,400
ಆದ್ದರಿಂದ ಈಗ ಒಂದು ರಚನೆ
ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ.

588
00:30:26,400 --> 00:30:31,490
ಆದರೆ ಅದರ ಬಗ್ಗೆ ಯೋಚಿಸಲು ಹೆಚ್ಚು ಸುಲಭ
ತಂತಿಗಳ ಈ ಕೇವಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

589
00:30:31,490 --> 00:30:34,900
>> ಹಾಗಿರುವಾಗ ಆವರಣ ಖಾಲಿ ಇರಬಹುದು?

590
00:30:34,900 --> 00:30:38,170
ಲೈಕ್, ನಾವು ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ
ಬ್ರಾಕೆಟ್ 5, ಬ್ರಾಕೆಟ್ ಎನ್?

591
00:30:38,170 --> 00:30:40,700

592
00:30:40,700 --> 00:30:41,200
ಹೌದು.

593
00:30:41,200 --> 00:30:43,731

594
00:30:43,731 --> 00:30:44,230
ಹೌದು.

595
00:30:44,230 --> 00:30:46,396
ನಾವು ಎಷ್ಟು ಗೊತ್ತಿಲ್ಲ
ಒಳಹರಿವು ಇರುತ್ತದೆ ಹೋಗುವ.

596
00:30:46,396 --> 00:30:53,560
ನಾವು ಖಣಿಲು ಉದಾಹರಣೆಗೆ ನೋಡಿದರೆ,
ನಾವು hello.c ಹಲೋ ಒ ಡ್ಯಾಶ್ ಖಣಿಲು ಹೇಳುತ್ತಾರೆ.

597
00:30:53,560 --> 00:30:56,710
ಈ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ, ಸಂಭವಿಸಿ
ಮೂರು ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಎಂದು.

598
00:30:56,710 --> 00:31:00,522
ಆದ್ದರಿಂದ brackets-- ನಾವು ನೋಡುತ್ತಾರೆ
ಎರಡನೇ ಅದನ್ನು ಮೂರು ನೆರವೇರಿಸಲಾಯಿತು.

599
00:31:00,522 --> 00:31:01,730
ಇದು ತಾಂತ್ರಿಕವಾಗಿ ನಾಲ್ಕು ಎಂದು.

600
00:31:01,730 --> 00:31:04,030
ಆದರೆ ಆವರಣ, ನಾವು
ಹೇಳುತ್ತಾರೆ, ಮೂರು ಇವೆ.

601
00:31:04,030 --> 00:31:08,220
ಆದರೆ ಈಗ ನಾವು ನಡೆಯ ನೋಡಿವೆ ವೇಳೆ
mario.c ಡಾಟ್ ಡಾಟ್, ಆವರಣ

602
00:31:08,220 --> 00:31:09,760
ನಾವು ಅವುಗಳನ್ನು ಎರಡು ಹಾಕಲು ಬಯಸುತ್ತೇನೆ.

603
00:31:09,760 --> 00:31:12,884
>> ಮತ್ತು ಆಜ್ಞೆಗಳನ್ನು ಬಹಳಷ್ಟು ಇವೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಅಸಂಖ್ಯಾತ ಹೊಂದಿವೆ

604
00:31:12,884 --> 00:31:13,620
ವಾದಗಳು.

605
00:31:13,620 --> 00:31:17,430
ಹಾಗಾಗಿ ಈ ಆವೃತ್ತಿಯಲ್ಲಿ
ಬ್ರಾಕೆಟ್ ಸಂಕೇತನ ಸೂಚಿಸುತ್ತದೆ

606
00:31:17,430 --> 00:31:20,820
argv ತಂತಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂದು.

607
00:31:20,820 --> 00:31:24,360
ಆದರೆ ನಾವು ಎಷ್ಟು ಗೊತ್ತಿಲ್ಲ
ತಂತಿಗಳನ್ನು ಆ ಶ್ರೇಣಿಯಲ್ಲಿನ ಇವೆ.

608
00:31:24,360 --> 00:31:27,090
ಮತ್ತು ಹೇಗೆ ನಾವು ನಂತರ ಹೇಗೆ ಗೊತ್ತು
ಅನೇಕ ತಂತಿಗಳನ್ನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಇವೆ?

609
00:31:27,090 --> 00:31:28,870
ಇಡೀ ಪಾಯಿಂಟುಗಳ argc ಇಲ್ಲಿದೆ.

610
00:31:28,870 --> 00:31:32,300
argc, argv ಎಷ್ಟು ತಿಳಿಸುತ್ತದೆ.

611
00:31:32,300 --> 00:31:36,500
>> ಕಳೆದ ವಿಷಯ ಇರಿಸಿಕೊಳ್ಳಲು
ಮನಸ್ಸಿನ, ತಾಂತ್ರಿಕವಾಗಿ ಆಗಿದೆ

612
00:31:36,500 --> 00:31:40,820
ಆಜ್ಞೆಯನ್ನು ಸ್ವತಃ ಒಂದು ಎಂದು ಲೆಕ್ಕ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಆಫ್.

613
00:31:40,820 --> 00:31:45,330
ಸಿಡಿ pset1 ಆದ್ದರಿಂದ, ಎರಡು ಇವೆ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

614
00:31:45,330 --> 00:31:50,260
ಸ್ವತಃ ಪ್ರೋಗ್ರಾಂ, ಸಿಡಿ, ಮತ್ತು ನಂತರ
ಇದು ನಿಜವಾದ ವಾದವನ್ನು ಭಾಗವಾಗಿ, pset1.

615
00:31:50,260 --> 00:31:54,490
ನೀವು ಇದುವರೆಗಿನ ಬರೆದ ಮಾಡಿದ ಆ ಪ್ರೋಗ್ರಾಮ್
ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ argument-- ಡಾಟ್ ಹೊಂದಿದೆ

616
00:31:54,490 --> 00:31:55,320
ಮಾರಿಯೋ ಕಡಿದು.

617
00:31:55,320 --> 00:31:57,350
ಕೇವಲ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವು.

618
00:31:57,350 --> 00:32:00,900
>> ಈಗ ಖಣಿಲು ನೋಡುವ
ಒ hello.c ಹಲೋ ಡ್ಯಾಶ್.

619
00:32:00,900 --> 00:32:01,905
ಆದ್ದರಿಂದ argc ಏನು?

620
00:32:01,905 --> 00:32:05,260

621
00:32:05,260 --> 00:32:06,080
4.

622
00:32:06,080 --> 00:32:08,140
ಆದ್ದರಿಂದ argc 4.

623
00:32:08,140 --> 00:32:12,140
ಖಣಿಲು, ಆದ್ದರಿಂದ argv ಬ್ರಾಕೆಟ್ 0 ಖಣಿಲು.

624
00:32:12,140 --> 00:32:15,630
argv ಬ್ರಾಕೆಟ್ 1 ಡ್ಯಾಶ್ 0.

625
00:32:15,630 --> 00:32:21,870
argv ಬ್ರಾಕೆಟ್ 2 ಹಲೋ, ಮತ್ತು
argv ಬ್ರಾಕೆಟ್ 3 hello.c ಹೊಂದಿದೆ.

626
00:32:21,870 --> 00:32:26,813
ಸರಿ, ಆದ್ದರಿಂದ ಈ ಪ್ರಶ್ನೆಗಳು, ಮತ್ತು ನಂತರ ನಾವು ಮಾಡುತ್ತೇವೆ
ಕೆಲವು ಆಯೋಜಿತ ಉದಾಹರಣೆಗಳು ನೋಡಲು.

627
00:32:26,813 --> 00:32:29,460

628
00:32:29,460 --> 00:32:30,480
>> ಸರಿ.

629
00:32:30,480 --> 00:32:36,260
ನಾವು hello3.c ನೋಡೋಣ ಮಾಡುತ್ತೇವೆ.

630
00:32:36,260 --> 00:32:41,890
ಆದ್ದರಿಂದ ಈ ಪರಿಚಿತ ಇರಬೇಕು
ಮೊದಲ ಸಿ ಉದಾಹರಣೆಯೆಂದು

631
00:32:41,890 --> 00:32:45,800
ನಾವು ಹೇಳಬಹುದು ಎಂದು ಅಲ್ಲಿ ನಾವು ಹಲೋ, ಹೊಂದಿತ್ತು
ವಿಶ್ವದ, ಆದರೆ ಈಗ ಈ ಸಾಮಾನ್ಯ ಆಗಿದೆ.

632
00:32:45,800 --> 00:32:52,300
ಇಲ್ಲಿ ನಾವು ಹಲೋ ಹೇಳುತ್ತಿದ್ದಾರೆ
% s ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎನ್ argv ಬ್ರಾಕೆಟ್ 1.

633
00:32:52,300 --> 00:32:57,440
ಇದುವರೆಗೂ ಅಪ್ ಆದ್ದರಿಂದ ಗಮನಿಸಿ, ಈ
ನನ್ನ ಟೆಂಪ್ಲೇಟ್ ಕಡತವನ್ನು ಕಾಣಿಸುತ್ತಾರೆ.

634
00:32:57,440 --> 00:33:01,800
ನಾನು ಇಂಟ್ ಮುಖ್ಯ (ಶೂನ್ಯ), ಮತ್ತು ನಂತರ ನಾನು
ಮುಖ್ಯ ಕಾರ್ಯದಲ್ಲಿ ಏನಾದರೂ.

635
00:33:01,800 --> 00:33:05,100
ಈಗ ಬದಲಾಗಿ ಒಮ್ಮೆ ನಾವು ವ್ಯವಹರಿಸುವಾಗ ಆರಂಭಿಸಲು
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಜೊತೆ,

636
00:33:05,100 --> 00:33:07,890
ನಾವು ಒಂದು ರಾಜ್ಯ ಬೇಕು
ಮುಖ್ಯ ವಿವಿಧ ರೂಪ.

637
00:33:07,890 --> 00:33:11,930
>> ಆದ್ದರಿಂದ hello3 ನೋಡುವ
ಮತ್ತೆ, ಮುಖ್ಯ ಹೋಗುತ್ತದೆ

638
00:33:11,930 --> 00:33:15,990
ಇಂಟ್ argc ಈಗ ಎರಡು ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು,
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಸಂಖ್ಯೆ

639
00:33:15,990 --> 00:33:20,970
ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಆವರಣ argv ನಿಜವಾದ
ತಂತಿಗಳನ್ನು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಪ್ರವೇಶಿಸಿತು.

640
00:33:20,970 --> 00:33:26,560
ಹಾಗಾಗಿ ಬದಲಾಯಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಟೆಂಪ್ಲೇಟ್ ವಾಸ್ತವವಾಗಿ ಪ್ರತಿಬಿಂಬಿಸಲು.

641
00:33:26,560 --> 00:33:29,060
ಈಗ ಬಂದ ನೀವು ಬರೆಯಲು
ಒಂದು ಪ್ರೋಗ್ರಾಂ, ನೀವು ವೇಳೆ

642
00:33:29,060 --> 00:33:33,720
ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ತೆಗೆದುಕೊಳ್ಳುವ ಅಗತ್ಯವಿಲ್ಲ
ವಾದಗಳು, ನಂತರ ಕೇವಲ ಇಂಟ್ ಮುಖ್ಯ (ಶೂನ್ಯ) ಬಳಸಿ.

643
00:33:33,720 --> 00:33:37,070
ಆದರೆ ಈಗ ನೀವು ಬರೆಯುವ ಮಾಡಿದಾಗ
ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ ಕಾರ್ಯಕ್ರಮಗಳು, ಇದು

644
00:33:37,070 --> 00:33:40,350
ನೀವು ಸಮಸ್ಯೆಗೆ ಮಾಡುವಾಗ ನೀನು
ಆದ್ದರಿಂದ ಈಗ ನೀವು ಚಾಲನೆ ಮಾಡುತ್ತಿರುವಿರಿ ಎಂದು two-- ಸೆಟ್

645
00:33:40,350 --> 00:33:42,630
ತೆಗೆದುಕೊಳ್ಳಬೇಕು ಎಂದು ಕಾರ್ಯಕ್ರಮಗಳು
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು,

646
00:33:42,630 --> 00:33:45,250
ಈ ಫಾರ್ಮ್ ಮುಖ್ಯ ಮಾಡಬೇಕು.

647
00:33:45,250 --> 00:33:51,290
>> ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಈ ದೊಡ್ಡ ಬಳಕೆ
ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದ.

648
00:33:51,290 --> 00:33:54,100
ಆದ್ದರಿಂದ argv 1 ಮುದ್ರಣ.

649
00:33:54,100 --> 00:33:59,180
ಸರಿ ನ ಕಂಪೈಲ್ ಅವಕಾಶ
ಮತ್ತು ಈ ಪ್ರೋಗ್ರಾಂ.

650
00:33:59,180 --> 00:34:02,440
Hello3 ಮಾಡಿ.

651
00:34:02,440 --> 00:34:03,570
ಸಂಗ್ರಹಿಸುತ್ತಾ.

652
00:34:03,570 --> 00:34:06,870
ಡಾಟ್ hello3 ಕಡಿದು.

653
00:34:06,870 --> 00:34:08,920
ಮತ್ತು, ಹೇಳಲು ಅವಕಾಶ "ರಾಬ್."

654
00:34:08,920 --> 00:34:10,760
ಹಲೋ ರಾಬ್.

655
00:34:10,760 --> 00:34:14,940
ನಾನು "ಹಲೋ ಮಾರಿಯಾ," ಹಲೋ ಮಾರಿಯಾ ಹೇಳಿದರೆ.

656
00:34:14,940 --> 00:34:15,719
ಮಾರಿಯಾ ಹಲೋ.

657
00:34:15,719 --> 00:34:18,639
ಹನ್ನಾ ಇನ್ನೂ ಹಲೋ "ಹೇಳುತ್ತಾರೆ
ಮಾರಿಯಾ, "ನಾನು ಮನುಷ್ಯ ಏಕೆಂದರೆ

658
00:34:18,639 --> 00:34:21,340
ನಮ್ಮ argv 2 ಏನು ಮಾಡುವುದರಿಂದ.

659
00:34:21,340 --> 00:34:22,590
Argv 2 ಈಗ "ಹನ್ನಾ." ಎಂದು

660
00:34:22,590 --> 00:34:25,030
Argc 3 ಆಗಿರುತ್ತದೆ.

661
00:34:25,030 --> 00:34:27,735
ನಾನು ಈ ಮಾಡಿದರೆ?

662
00:34:27,735 --> 00:34:31,980

663
00:34:31,980 --> 00:34:34,679
ಹಲೋ ಆದ್ದರಿಂದ ಶೂನ್ಯ.

664
00:34:34,679 --> 00:34:38,760
>> ಆತ ವಾಸ್ತವವಾಗಿ ಮುಟ್ಟಲಿಲ್ಲ
ಎಂದು, ತಾಂತ್ರಿಕವಾಗಿ, GetString

665
00:34:38,760 --> 00:34:42,429
ಶೂನ್ಯ ಹಿಂತಿರುಗಿ ಇರಬಹುದು, ಆದರೆ ನಾವು ಒಂದು ಪಡೆಯುತ್ತೀರಿ
ಹೆಚ್ಚು ಏನು ಶೂನ್ಯ ಒಳಗೆ ಬಹಳಷ್ಟು ವಾಸ್ತವವಾಗಿ.

666
00:34:42,429 --> 00:34:47,449
ಆದರೆ ಒಂದು ವಿಚಾರವನ್ನು ತೆಗೆದುಕೊಂಡು
ಯಾವುದೇ ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ಎನ್ನುವ.

667
00:34:47,449 --> 00:34:50,179
ನಾವು ವೇಳೆ ಏನೋ ಮಾಡಿದರು
ಇದು "ಹಲೋ ಶೂನ್ಯ." ಮುದ್ರಣ

668
00:34:50,179 --> 00:34:52,179
ಮತ್ತು ಕಾರಣ ನಾವು ಮಾಡಿದ
is-- ಚೆನ್ನಾಗಿ ಏನೋ,

669
00:34:52,179 --> 00:34:56,179
ನಾನು ಡಾಟ್ ಕತ್ತರಿಸಿ hello3 ನಡೆಸುತ್ತಿದ್ದರು, argc 1 ಆಗಿತ್ತು.

670
00:34:56,179 --> 00:34:59,680
ಆದ್ದರಿಂದ argv ಉದ್ದ 1 ಅರ್ಥ.

671
00:34:59,680 --> 00:35:05,110
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಉದ್ದ 1 ವೇಳೆ,
ಮಾತ್ರ ಮಾನ್ಯ ಸೂಚ್ಯಂಕ ಶೂನ್ಯವಾಗಿರುತ್ತದೆ.

672
00:35:05,110 --> 00:35:08,550
ಮತ್ತು ಇಲ್ಲಿ 1 ಹೊರಗಿದೆ argv
ಈ ರಚನೆಯ ವ್ಯಾಪ್ತಿ.

673
00:35:08,550 --> 00:35:13,410
ನಾನು ಪ್ರಯತ್ನಿಸಿದಾಗ ಮೊದಲು ಹೋಲುತ್ತಿತ್ತು
ರಚನೆಯ ಕೊನೆಯ ಹೊರಗೆ 6 ಶೇಖರಿಸಿಡಲು.

674
00:35:13,410 --> 00:35:18,100
ಹಾಗಾಗಿ ಏನೋ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ ನಾನು
argv ಎಣಿಕೆಗಳು ಹೊರಗೆ,

675
00:35:18,100 --> 00:35:21,340
ಮತ್ತು ನಾವು ಶೂನ್ಯ ಬರುತ್ತಿದೆ.

676
00:35:21,340 --> 00:35:24,360
>> ಆದ್ದರಿಂದ ಒಂದು ಉತ್ತಮ ಆವೃತ್ತಿ
ಈ, ಸುಧಾರಣೆ,

677
00:35:24,360 --> 00:35:27,010
ಸ್ಪಷ್ಟವಾಗಿ argc, ತಪಾಸಣೆ ಇದೆ.

678
00:35:27,010 --> 00:35:33,580
Argc 2 ಸಮನಾಗಿರುತ್ತದೆ ಆದ್ದರಿಂದ, ನಾವು ಓಡಿ ಅರ್ಥ
ಡಾಟ್ ಕತ್ತರಿಸಿ hello3 ರಾಬ್ ರೀತಿಯ.

679
00:35:33,580 --> 00:35:36,840
ಮತ್ತು ಇದು "ಹಲೋ ರಾಬ್." ಮುದ್ರಿಸಿ

680
00:35:36,840 --> 00:35:39,850
Argc ಸಮಾನ ಇದ್ದರೆ
2, ಅದು ಕೇವಲ ವಿಶೇಷವೇನು

681
00:35:39,850 --> 00:35:42,560
ನೀವು ಪುಟ್ ಯಾವುದೇ ನಿರ್ಲಕ್ಷಿಸಿ
ಆಜ್ಞಾ ಸಾಲಿನ ವಾದವನ್ನು

682
00:35:42,560 --> 00:35:43,960
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಎಂದು.

683
00:35:43,960 --> 00:35:47,168
ನೀವು ಯಾವುದೇ ಪುಟ್ ಮಾಡದಿದ್ದಲ್ಲಿ ಅಥವಾ, ಅದು
ಆ ನಿರ್ಲಕ್ಷಿಸಿ ಕೇವಲ ಹೇಳಲು ವಿಶೇಷವೇನು,

684
00:35:47,168 --> 00:35:47,960
"ನೀವು ಹಲೋ."

685
00:35:47,960 --> 00:35:51,490
>> ಆದ್ದರಿಂದ ಈ ಕಂಪೈಲ್.

686
00:35:51,490 --> 00:35:54,500
Hello4 ಮಾಡಿ.

687
00:35:54,500 --> 00:35:56,790
ಮತ್ತು hello4 ಚಾಲನೆಯಲ್ಲಿರುವ.

688
00:35:56,790 --> 00:36:00,010
ಈ ರೀತಿ ರನ್ನಿಂಗ್,
ಯಾವ ಮುದ್ರಿತ ಮಾಡಬೇಕು?

689
00:36:00,010 --> 00:36:01,330
"ನೀವು ಹಲೋ."

690
00:36:01,330 --> 00:36:02,810
ನೀವು ಹಲೋ.

691
00:36:02,810 --> 00:36:05,870
ಏನು hello4 ರಾಬ್ ಬಗ್ಗೆ?

692
00:36:05,870 --> 00:36:06,950
"ಹಲೋ, ರಾಬ್."

693
00:36:06,950 --> 00:36:10,580
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಹಲೋ ರಾಬ್ ಮಾರಿಯಾ
"ಹಲೋ ನೀವು" ಮತ್ತೆ ಕೇವಲ

694
00:36:10,580 --> 00:36:13,677
ನೀವು ನಿಜವಾಗಿಯೂ ನಮೂದಿಸಿ ಏಕೆಂದರೆ
ಅಪೇಕ್ಷಿಸಿದ ವಿಷಯ.

695
00:36:13,677 --> 00:36:15,510
ನೀವು ಹೆಚ್ಚು ಹೆಸರುಗಳು ಪ್ರವೇಶಿಸಿತು
ಇದು ನಿಭಾಯಿಸಬಲ್ಲ ಹೆಚ್ಚು,

696
00:36:15,510 --> 00:36:19,500
ಆದ್ದರಿಂದ ಕೇವಲ ಪೂರ್ವನಿಯೋಜಿತಗೊಳಿಸಲಾಗುತ್ತದೆ
ಹಲೋ ನೀವು ನಡವಳಿಕೆ.

697
00:36:19,500 --> 00:36:23,040
ಈ ಪ್ರಶ್ನೆಗಳನ್ನು ಆದ್ದರಿಂದ?

698
00:36:23,040 --> 00:36:26,290
ಅಥವಾ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು?

699
00:36:26,290 --> 00:36:28,690
>> ಸರಿ, ಆದ್ದರಿಂದ ಒಂದು ನೋಟ ತೆಗೆದುಕೊಂಡು
ಬಳಸುವ ಒಂದೆರಡು ಉದಾಹರಣೆಗಳು

700
00:36:28,690 --> 00:36:34,230
ಆಜ್ಞಾ ಸಾಲಿನ ಮೊದಲ arguments--
ನಾವು ಡ್ಯಾಶ್ 1 ಡಾಟ್ ಸಿ argv ಮಾಡಿದ್ದಾರೆ.

701
00:36:34,230 --> 00:36:38,510
ಆದ್ದರಿಂದ ಕಾಮೆಂಟ್ಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆಂದು ಏನು
ಈ ಪ್ರೋಗ್ರಾಂ ಏನು ಮಾಡಬೇಕು.

702
00:36:38,510 --> 00:36:42,460
ಆದರೆ, ಲೂಪ್ ಈ ಈಗ ಗಮನಕ್ಕೆ
ಈ ನಿಖರ ಮಾದರಿಗೆ ಹೊಂದುವಂತಿದ್ದರೆ

703
00:36:42,460 --> 00:36:43,390
ನಾನು ಮೊದಲು ಹೇಳಿಕೆಯ.

704
00:36:43,390 --> 00:36:46,240
ನಾವು ಎಂದು ಸಂಭವಿಸಿ
ಬದಲಿಗೆ n ನ argc ಬಳಸಿ.

705
00:36:46,240 --> 00:36:48,880
ಈಗ argc ನಿಜವಾಗಿಯೂ n ಇದೆ.

706
00:36:48,880 --> 00:36:51,260
ಇದು argv ರಚನೆಯ ಉದ್ದ ಇಲ್ಲಿದೆ.

707
00:36:51,260 --> 00:36:59,600
ಆದ್ದರಿಂದ argv ಮೇಲೆ iterating
ಶ್ರೇಣಿಯನ್ನು printf ಮಾಡುವ ಪ್ರತಿ argv ಮೌಲ್ಯವನ್ನು.

708
00:36:59,600 --> 00:37:04,730
>> ನಾನು ಈ ಮಾಡಲು ಆದ್ದರಿಂದ.

709
00:37:04,730 --> 00:37:08,232
Argv 1 ಮಾಡಿ.

710
00:37:08,232 --> 00:37:09,940
ಇದು ಸಂಗ್ರಹಿಸುತ್ತಾ.

711
00:37:09,940 --> 00:37:11,620
ಡಾಟ್ argv 1 ಕಡಿದು.

712
00:37:11,620 --> 00:37:15,530
ಈ ಚಾಲನೆಯಲ್ಲಿರುವ, ಇದು
ಮುದ್ರಿತ ಕಡಿದು argv 1 ಡಾಟ್

713
00:37:15,530 --> 00:37:18,500
ಕೇವಲ ಆಜ್ಞಾ ಸಾಲಿನ ಕಾರಣ
ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು argument--.

714
00:37:18,500 --> 00:37:22,080
ಯಾವಾಗಲೂ least-- ನಲ್ಲಿ ಇರುತ್ತದೆ
argc, ಒಂದು ಕಡಿಮೆ ಸಾಧ್ಯವಿಲ್ಲ

715
00:37:22,080 --> 00:37:25,910
ರಿಂದ ಯಾವಾಗಲೂ ಕನಿಷ್ಠ
ಚಲಾಯಿಸಲು ಪ್ರೋಗ್ರಾಂ ಹೆಸರು.

716
00:37:25,910 --> 00:37:32,040
ಆದ್ದರಿಂದ 1 ರಾಬ್ 1 ಮುದ್ರಣ argv ಮಾಡುತ್ತದೆ argv
ತದನಂತರ ಹೊಸ ಸಾಲಿನಲ್ಲಿ "ರಾಬ್."

717
00:37:32,040 --> 00:37:36,350
>> ಮೊದಲ ಪುನರಾವರ್ತನೆ ಆದ್ದರಿಂದ
ಈ ಲೂಪ್, ನಾನು 0.

718
00:37:36,350 --> 00:37:39,090
Argv 0 ಪ್ರೋಗ್ರಾಂ ಹೆಸರು.

719
00:37:39,090 --> 00:37:40,010
ಡಾಟ್ argv 1 ಕಡಿದು.

720
00:37:40,010 --> 00:37:43,770
ತದನಂತರ 1 ನನ್ನ ಮೊದಲ argv
ರಾಬ್ ಇದು ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ,.

721
00:37:43,770 --> 00:37:45,920
ಈ ಹಂತದಲ್ಲಿ, ನಾವು argc ಸಮನಾಗಿವೆ.

722
00:37:45,920 --> 00:37:48,210
ನಾವು ಲೂಪ್ ಭೇದಿಸಿ ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.

723
00:37:48,210 --> 00:37:53,940
ಆದ್ದರಿಂದ ಈ ಒಂದು ಕ್ರಮವಿಲ್ಲದ ಕೆಲಸ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಸಂಖ್ಯೆ.

724
00:37:53,940 --> 00:37:58,550
ಗಮನಿಸಿ ಇದು argv 0, argv ಮುದ್ರಿಸುತ್ತದೆ
1, argv 2, argv 3, argv 4.

725
00:37:58,550 --> 00:38:00,150
ಮತ್ತು ಯಾವುದೇ argv 5 ಇಲ್ಲ.

726
00:38:00,150 --> 00:38:01,460
argc 5 ಸಮಾನವಾಗಿರುತ್ತದೆ.

727
00:38:01,460 --> 00:38:06,960
ಹಾಗಾಗಿ 5 ಸಮ ನಲ್ಲಿ argc-- ನಲ್ಲಿ,
ನಾವು ಲೂಪ್ ಭೇದಿಸಿ.

728
00:38:06,960 --> 00:38:07,950
ಸರಿ.

729
00:38:07,950 --> 00:38:11,315
ನಾವು ಮೊದಲು ಆ ಮೇಲೆ ಪ್ರಶ್ನೆಗಳನ್ನು ಆದ್ದರಿಂದ
ಒಂದು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಉದಾಹರಣೆ ನೋಡಲು?

730
00:38:11,315 --> 00:38:14,190

731
00:38:14,190 --> 00:38:16,860
>> ಆದ್ದರಿಂದ 2 argv.

732
00:38:16,860 --> 00:38:17,830
ಆಯ್ತು.

733
00:38:17,830 --> 00:38:20,610
ನಾವು ಇನ್ನೂ ಮುದ್ರಿಸುವ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು.

734
00:38:20,610 --> 00:38:23,170
ಆದರೆ ಈಗ ನಾವು ಗಮನಿಸಿ
ಲೂಪ್ ರೀತಿಯಲ್ಲಿ.

735
00:38:23,170 --> 00:38:24,670
ಹಾಗಾಗಿ ಈ ರೀತಿ ಇದೆ?

736
00:38:24,670 --> 00:38:28,430
ಆದ್ದರಿಂದ ಮೊದಲ ಲೂಪ್ ಮಾಡುತ್ತಿರುವ
ನಿಖರವಾಗಿ ಇದು ಮೊದಲು ಮಾಡಿದರು.

737
00:38:28,430 --> 00:38:30,950
ನಾವು ಇನ್ನೂ ಮೇಲೆ ಆವರ್ತಿಸುವ
ಪ್ರತಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ,

738
00:38:30,950 --> 00:38:34,260
ಆದರೆ ಈಗ ಈ ಎರಡನೇ ಲೂಪ್ ನಾವು ಬಂದಿದೆ
ಸಹ ಮೊದಲು ಈ ರೀತಿಯ ಕಾಣಬಹುದು.

739
00:38:34,260 --> 00:38:38,600
ಅವರು ಮೇಲೆ iterating ಮಾಡಿದಾಗ
Zamyla ಝಡ್ ಎ ಎಂ ವೈ ಎಲ್ ಎ ಮುದ್ರಿಸುವ.

740
00:38:38,600 --> 00:38:44,816
ಆದ್ದರಿಂದ ಇಂಟ್ ಜೆ ಈ ಎರಡನೇ ಲೂಪ್ ಸಮನಾಗಿರುತ್ತದೆ
0, ಎನ್, argv ಬ್ರಾಕೆಟ್ ನಾನು strlen ಸಮನಾಗಿರುತ್ತದೆ.

741
00:38:44,816 --> 00:38:49,170
>> ಆದ್ದರಿಂದ ಮೊದಲ ಆಲೋಚಿಸುತ್ತೀರಿ ತಿಳಿಸಿ
ಮುಚ್ಚಲಿದೆ ಸಂಚರಿಸಲು ಅವಕಾಶ.

742
00:38:49,170 --> 00:38:53,560
ನ ಕಂಪ್ಯೂಟರ್ ಯೋಚಿಸಿದ್ದೇವೆ ಲೆಟ್
ಕೇವಲ ಡಾಟ್ ನಾನು ಈ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಿರ್ವಹಿಸಿದ ಏನು

743
00:38:53,560 --> 00:38:56,030
argv ಡ್ಯಾಶ್ 2 ಕಡಿದು.

744
00:38:56,030 --> 00:39:03,590
ಆದ್ದರಿಂದ ನಾನು, ಈ ಕೋಡ್ ನಡೆಯಿತು
argc 1 ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂದು ನಾನು.

745
00:39:03,590 --> 00:39:07,050
ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಮಾತ್ರ ಇಲ್ಲ argv--
, argv ಒಂದು ಸೂಚಕ ಏರಲಿದೆ,

746
00:39:07,050 --> 00:39:12,370
ಮತ್ತು ಡಾಟ್ ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂದು ವಿಶೇಷವೇನು
argv ಕಡಿದು 2-- ಪ್ರೋಗ್ರಾಂ ಹೆಸರು.

747
00:39:12,370 --> 00:39:19,170
>> ಸರಿ, ಈಗ ನಾನು ಹೆಚ್ಚು ನಾನು ಕಡಿಮೆ, 0 ಸಮನಾಗಿರುತ್ತದೆ
1, ನಾನು ಜೊತೆಗೆ ಇಂಟ್ ಜೆ 0 ಸಮನಾಗಿರುತ್ತದೆ,

748
00:39:19,170 --> 00:39:23,880
ಎನ್ ಆದ್ದರಿಂದ argv ಬ್ರಾಕೆಟ್ 0 strlen ಸಮನಾಗಿರುತ್ತದೆ
ಈ ಲೂಪ್ ಮೊದಲ ಪುನರಾವರ್ತನೆ. argv

749
00:39:23,880 --> 00:39:27,250
ಬ್ರಾಕೆಟ್ 0 ಡಾಟ್ ಕತ್ತರಿಸಿ argv 2.

750
00:39:27,250 --> 00:39:29,320
ಆದ್ದರಿಂದ ಒಂದು ತಂತುವಿನ ಉದ್ದ ಏನು?

751
00:39:29,320 --> 00:39:32,480
ಸರಿ, ಎ ಆರ್ ಜಿ ವಿ ಡ್ಯಾಶ್ 2 ಡಾಟ್ ಕತ್ತರಿಸಿ.

752
00:39:32,480 --> 00:39:35,020
ಆ strlen ಆದ್ದರಿಂದ 8 ಇರುತ್ತದೆ.

753
00:39:35,020 --> 00:39:37,500
ಆದ್ದರಿಂದ ಜೆ 0 ಸಮನಾಗಿರುತ್ತದೆ N 8 ಸಮನಾಗಿರುತ್ತದೆ.

754
00:39:37,500 --> 00:39:39,530
ಎಲ್ಲಿಯವರೆಗೆ ಜೆ 8, J ++ ಕಡಿಮೆ ಎಂದು.

755
00:39:39,530 --> 00:39:44,080
ಮತ್ತು ಆ ಮೂಲಕ ನಾವು ಎಂದು ನೀನು
ಒಂದು ಪಾತ್ರ ಮುದ್ರಣ ಇದು

756
00:39:44,080 --> 00:39:47,350
ನಾನು ಜೆ ಬ್ರಾಕೆಟ್ argv ಬ್ರಾಕೆಟ್ ಆಗಿದೆ.

757
00:39:47,350 --> 00:39:49,826
>> ಆದ್ದರಿಂದ ನಾನು ಶೂನ್ಯವಾಗಿರುತ್ತದೆ.

758
00:39:49,826 --> 00:39:51,700
ನಾವು ಇನ್ನೂ ಒಂದು ಹೊಂದಿವೆ
ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ.

759
00:39:51,700 --> 00:39:53,890
ಮೊದಲ ಪುನರಾವರ್ತನೆ
ಲೂಪ್, ನಾವು ಆರ್

760
00:39:53,890 --> 00:39:56,950
ಮುದ್ರಣ ಎಂದು ನಾನು
argv ಬ್ರಾಕೆಟ್ 0 ಬ್ರಾಕೆಟ್ 0.

761
00:39:56,950 --> 00:39:58,325
ತದನಂತರ ಜೆ ಹೆಚ್ಚಿಸಲು ಹೋಗುತ್ತದೆ.

762
00:39:58,325 --> 00:40:01,650
ನಾವು ಮುದ್ರಣ ನೀನು
argv ಬ್ರಾಕೆಟ್ 0 ಬ್ರಾಕೆಟ್ 1.

763
00:40:01,650 --> 00:40:04,150
ತದನಂತರ ಬ್ರಾಕೆಟ್ 0 ಬ್ರಾಕೆಟ್ 2, argv.

764
00:40:04,150 --> 00:40:09,030
>> ಆದ್ದರಿಂದ ಈ ನಮ್ಮ ಮೊದಲ ಎನ್ಕೌಂಟರ್
ಬಹು ಆಯಾಮದ ಸರಣಿಗಳ.

765
00:40:09,030 --> 00:40:12,770
ನಾನು ಹೇಳಿದರು ಹಿಂದಿನ ನೆನಪಿಡಿ
ಎಂದು argv ತಾಂತ್ರಿಕವಾಗಿ

766
00:40:12,770 --> 00:40:15,950
ಪಾತ್ರಗಳ ಸರಣಿಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

767
00:40:15,950 --> 00:40:24,360
ಇಲ್ಲಿ ನಾನು ಏನೋ ಹೇಳಿದರು
ಸ್ಟ್ರಿಂಗ್ ರು, argv ಬ್ರಾಕೆಟ್ ನಾನು ಸಮನಾಗಿರುತ್ತದೆ

768
00:40:24,360 --> 00:40:29,590
ಮತ್ತು ನಂತರ ನಾನು ರು ಹೇಳಿದರು ಬ್ರಾಕೆಟ್ ಜೆ, ಈ
ಒಂದೇ ಸಾಧಿಸಲು ಎಂದು.

769
00:40:29,590 --> 00:40:31,960
ಈಗ, ನೀವು ಮೊದಲು ರು ಬ್ರಾಕೆಟ್ ಜೆ ನೋಡಿದ.

770
00:40:31,960 --> 00:40:36,680
ಕೇವಲ ಜೆ ನೇ ಪ್ರವೇಶಿಸಲು ವಿಶೇಷವೇನು
ಈ ತಂತುವಿನ ಪಾತ್ರ.

771
00:40:36,680 --> 00:40:48,010
ಈ ಜೊತೆಗೆ, ನಾವು ಪಡೆಯುತ್ತಿದ್ದಾರೆ
I- ನೇ argv ಜೆ ನೇ ಅಕ್ಷರ.

772
00:40:48,010 --> 00:40:51,450
>> ಹಾಗಾಗಿ ಈ ಅಂತಿಮವಾಗಿ ಔಟ್ಪುಟ್ ಮಾಡಬೇಕು?

773
00:40:51,450 --> 00:40:53,210
Argv 2 ಮಾಡಿ.

774
00:40:53,210 --> 00:40:54,730
ಇದು ಸಂಗ್ರಹಿಸುತ್ತಾ.

775
00:40:54,730 --> 00:40:56,340
ಡಾಟ್ argv 2 ಕಡಿದು.

776
00:40:56,340 --> 00:41:03,790
"ರಾಬ್ ಮಾರಿಯಾ ಹನ್ನಾ,"
ಮತ್ತು ನಮಗೆ ಕೆಲವು ಕೊಠಡಿ ನೀಡಲು.

777
00:41:03,790 --> 00:41:07,050
ಆದ್ದರಿಂದ ನಾವು ಈ ಉತ್ಪಾದಿಸುವ ಎಂದು ನೋಡಿ
ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ ಮತ್ತು ಕತ್ತರಿಸಿ ಡಾಟ್

778
00:41:07,050 --> 00:41:08,920
ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ ತನ್ನದೇ ಸಾಲಿನಲ್ಲಿ ಮತ್ತು ಮೇಲೆ.

779
00:41:08,920 --> 00:41:11,260
ಇದನ್ನು ಪ್ರತಿ ಮುದ್ರಿಸುವ
ಪ್ರತ್ಯೇಕ ಪಾತ್ರ

780
00:41:11,260 --> 00:41:12,950
ಪ್ರತಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದ.

781
00:41:12,950 --> 00:41:15,960
ತದನಂತರ ಅವುಗಳ ಮಧ್ಯೆ,
ಏಕೆಂದರೆ ಈ ಹೊಸ ಮಾರ್ಗ

782
00:41:15,960 --> 00:41:19,380
ನಾವು, ಇಲ್ಲಿ ಕೆಳಗೆ ಮುದ್ರಿಸುವ
ಅವುಗಳ ನಡುವೆ ಇದು ಒಂದು ಹೊಸ ಸಾಲು ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ.

783
00:41:19,380 --> 00:41:24,540
>> ಆದ್ದರಿಂದ ಈ ಹೋಲುತ್ತದೆ
ಮೊದಲು argv ಡ್ಯಾಶ್ 1,

784
00:41:24,540 --> 00:41:26,459
ಪ್ರತಿ ಮುದ್ರಿತ
ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ,

785
00:41:26,459 --> 00:41:28,500
ಆದರೆ ಈಗ ನಾವು ಮುದ್ರಿಸುವ ನೀವು
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು

786
00:41:28,500 --> 00:41:31,950
ಮತ್ತು ನಂತರ ಪ್ರತಿ ಮೂಲಕ iterating
ಪ್ರತಿ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದ ರ

787
00:41:31,950 --> 00:41:35,400
ಈ ಉತ್ಪಾದನೆ ಪಡೆಯಲು.

788
00:41:35,400 --> 00:41:36,870
ಸರಿ?

789
00:41:36,870 --> 00:41:40,570
ಈ ಪ್ರಶ್ನೆಗಳನ್ನು ಆದ್ದರಿಂದ?

790
00:41:40,570 --> 00:41:45,130
>> ಗಮನಿಸಬೇಕಾದ ಒಂದು ವಿಷಯವೆಂದರೆ ಎಂದು
ಆಜ್ಞಾ ಸಾಲಿನ arguments--

791
00:41:45,130 --> 00:41:49,990
ಆದ್ದರಿಂದ ಅವರು ಸ್ಥಳಗಳಲ್ಲಿ ಬೇರ್ಪಡಿಸಲಾಗಿರುತ್ತದೆ
ನೀವು ನೈಸರ್ಗಿಕವಾಗಿ ಅವರಿಗೆ ಎಂದು ನಿರೀಕ್ಷಿಸಬಹುದು.

792
00:41:49,990 --> 00:41:53,050
ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ಇದು ಖಾಲಿ ಹೊಂದಬಹುದು.

793
00:41:53,050 --> 00:41:57,380
ಇದು ಸೂಪರ್ ಮುಖ್ಯ ಅಲ್ಲ, ಆದರೆ ನಾನು ವೇಳೆ
ಮೂರನೇ ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ ಬೇಕಾಗಿದ್ದಾರೆ

794
00:41:57,380 --> 00:42:01,226
ನಾನು ನಂತರ, ಇದು ಒಂದು ಸ್ಥಳವನ್ನು
ಈ ರೀತಿಯ ಹೇಳಬಹುದು.

795
00:42:01,226 --> 00:42:04,470

796
00:42:04,470 --> 00:42:05,550
ಸರಿ?

797
00:42:05,550 --> 00:42:12,190
ಆದ್ದರಿಂದ ಈಗ ಇನ್ನೂ ಕೇವಲ ಮೂರು ಹೊಂದಿದೆ
ಆಜ್ಞಾ ಸಾಲಿನ arguments-- ಹಾಗೂ 4.

798
00:42:12,190 --> 00:42:17,620
ಡಾಟ್ argv ಡ್ಯಾಶ್ 2 ಕಡಿದು, ರಾಬ್,
ಮಾರಿಯಾ ಮತ್ತು ಹನ್ನಾ ಬ್ಲೂಮ್ಬರ್ಗ್.

799
00:42:17,620 --> 00:42:18,320
ಸರಿ.

800
00:42:18,320 --> 00:42:19,310
ಈ ಪ್ರಶ್ನೆಗಳು?

801
00:42:19,310 --> 00:42:22,700

802
00:42:22,700 --> 00:42:24,894
>> ವಿಶೇಷ ಇಲ್ಲ
ಬಾಹ್ಯಾಕಾಶ ಪಾತ್ರದ ಬಗ್ಗೆ.

803
00:42:24,894 --> 00:42:27,810
ಅದು ಆ ಮನೆಯಿದ್ದ
ಆಜ್ಞಾ ಸಾಲಿನ ಜಾಗವನ್ನು ಪಾತ್ರ ಪರಿಗಣಿಸುತ್ತದೆ

804
00:42:27,810 --> 00:42:29,226
ಹೇಗೆ ನೀವು ಪ್ರತಿ ವಾದವನ್ನು ಬೇರ್ಪಡಿಸಿ.

805
00:42:29,226 --> 00:42:32,048

806
00:42:32,048 --> 00:42:33,000
ಆಯ್ತು.

807
00:42:33,000 --> 00:42:39,950
ಆದ್ದರಿಂದ ಸಮಸ್ಯೆ ಸೆಟ್
ನೀವು ಎಂದು ನೀನು two--

808
00:42:39,950 --> 00:42:43,240
ರಹಸ್ಯ ಕೀ ಗುಪ್ತ ನೋಡುವ.

809
00:42:43,240 --> 00:42:47,700
ಉದಾಹರಣೆಗೆ ಆದ್ದರಿಂದ, ಇದೇ
ನಾವು, ಎ ಕ್ರಿಸ್ಮಸ್ ಸ್ಟೋರಿ ಕಂಡ

810
00:42:47,700 --> 00:42:52,840
ನೀವು ಕೆಲವು ಅನುಷ್ಠಾನಕ್ಕೆ ನೀನು
, ಒಂದು ಸಂದೇಶವನ್ನು ನೀಡಿದ ಕ್ರಮಾವಳಿಗಳು

811
00:42:52,840 --> 00:42:55,560
ನೀವು ಸಾಧ್ಯವಾಗುತ್ತದೆ ನೀನು
ಆ ಸಂದೇಶವನ್ನು ಗೂಢಲಿಪೀಕರಿಸಲು

812
00:42:55,560 --> 00:42:58,730
ಆ ರಹಸ್ಯ ಮಾತ್ರ ಯಾರಾದರೂ
ಪ್ರಮುಖ, ಎಂದು ಡಿಕೋಡರ್ ರಿಂಗ್ ಜೊತೆ,

813
00:42:58,730 --> 00:43:01,090
ಡೀಕ್ರಿಪ್ಟ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

814
00:43:01,090 --> 00:43:04,839
>> ಆದ್ದರಿಂದ ಪ್ರಮಾಣಿತ ಆವೃತ್ತಿಯಾಗಿದೆ.

815
00:43:04,839 --> 00:43:07,130
ನೀವು ಕಾರ್ಯಗತ ಮಾಡಲು ನೀನು
ಎರಡು ವಿವಿಧ ಆವೃತ್ತಿಗಳು.

816
00:43:07,130 --> 00:43:09,620
ನೀವು ಒಂದು ನೋಟ ಪಡೆಯಲು ಸಂಭವಿಸಿದಾಗ
ಹ್ಯಾಕರ್ ಈಗ Edition-- ನಲ್ಲಿ,

817
00:43:09,620 --> 00:43:12,600
ನಾವು ನೀಡಲು ನೀನು
ನೀವು ಈ ರೀತಿಯ ಒಂದು ಸ್ಟ್ರಿಂಗ್,

818
00:43:12,600 --> 00:43:15,240
ಇದು ಒಂದು ಗೂಢಲಿಪೀಕರಣಗೊಂಡ ಗುಪ್ತಪದವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

819
00:43:15,240 --> 00:43:19,990
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಗುರಿ ಲೆಕ್ಕಾಚಾರ ಹೊಂದಿದೆ
ಅಸಂಕೇತಿಕರಿಸಿದ ಗುಪ್ತಪದವನ್ನು ಏನು.

820
00:43:19,990 --> 00:43:26,950
ಈಗ ಈ ವಾಸ್ತವವಾಗಿ ಹೇಗೆ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಹೊಂದಿದೆ
ಕಂಪ್ಯೂಟರ್ಗಳ ಸಾಕಷ್ಟು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ,

821
00:43:26,950 --> 00:43:31,290
ಮತ್ತು ಇದು ಕೇವಲ ಈ ಸಂಗ್ರಹಿಸುತ್ತದೆ
ಪಾತ್ರಗಳ ಯಾದೃಚ್ಛಿಕ ಸ್ಟ್ರಿಂಗ್.

822
00:43:31,290 --> 00:43:34,440
ನೀವು ಹೇಗೆ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಹೊಂದಿರುತ್ತವೆ
ಪಾತ್ರಗಳ ಈ ಯಾದೃಚ್ಛಿಕ ಸ್ಟ್ರಿಂಗ್

823
00:43:34,440 --> 00:43:36,140
ಪಾಸ್ವರ್ಡ್ ಇದ್ದ.

824
00:43:36,140 --> 00:43:39,060

825
00:43:39,060 --> 00:43:43,290
>> ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಂತರ ಈ
ಸಮಸ್ಯೆ ಸೆಟ್, ನೀವು

826
00:43:43,290 --> 00:43:46,100
ಅರ್ಥ ಏನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

827
00:43:46,100 --> 00:43:51,650
ಆದ್ದರಿಂದ ನೀವು ಡೀಕ್ರಿಪ್ಟ್ ಹೇಗೆ ಕಲಿಯುವಿರಿ
ಯಾದೃಚ್ಛಿಕ ಸ್ಟ್ರಿಂಗ್ ಈ ರೀತಿಯ.

828
00:43:51,650 --> 00:43:56,390
ಹಾಗೆಯೇ, ನೀವು ವಾರದಲ್ಲಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ
0, ಈ ಕೊಂಡಿಯ ನೋಡಿರಬಹುದು.

829
00:43:56,390 --> 00:44:00,210
ಮತ್ತು ನೀವು ಸಾಧ್ಯವಾಗುತ್ತದೆ
ಅಂತಿಮವಾಗಿ ಈ ಡೀಕ್ರಿಪ್ಟ್.

830
00:44:00,210 --> 00:44:04,810
ನೀವು ಸಂತೋಷದಿಂದ ಇರಬಹುದು ನೀವು
ಡೀಕ್ರಿಪ್ಟ್ ಮತ್ತು ಲಿಂಕ್ ಕ್ಲಿಕ್ ಮಾಡಿ.

831
00:44:04,810 --> 00:44:05,700
ಆಯ್ತು.

832
00:44:05,700 --> 00:44:06,591
ಇಂದು ಅದು.

833
00:44:06,591 --> 00:44:12,095
ಆದ್ದರಿಂದ ಮುಂದಿನ ವಾರ ನೀವು ನೋಡಿ!

834
00:44:12,095 --> 00:44:18,315
>> [ವಿದ್ಯುನ್ಮಾನ ಸಂಗೀತ]

835
00:44:18,315 --> 00:47:15,619