1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> ಸ್ಪೀಕರ್ 1: ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ.

3
00:00:05,680 --> 00:00:07,530
ನಾವು ಪ್ರಾರಂಭಿಸಲು ಹೋಗುವ.

4
00:00:07,530 --> 00:00:09,330
ನಾನು ಜನರು ಇನ್ನೂ ಹೋಗುವ ಭಾವಿಸುತ್ತೇನೆ
ಸೋಸುವಿಕೆಯ ಎಂದು.

5
00:00:09,330 --> 00:00:12,840
ಆದರೆ ಆ ಬಗ್ಗೆ, ನಾವು ಎಷ್ಟು
ಸಮಯಕ್ಕೆ ಇಲ್ಲಿ ಹೊರಗೆ ನೀವು ಹುಡುಗರಿಗೆ ಪಡೆಯಲು,

6
00:00:12,840 --> 00:00:14,110
ನಾವು ಆರಂಭಿಸಲು ನೀನು.

7
00:00:14,110 --> 00:00:18,780
ಆದ್ದರಿಂದ CS50 ರಸಪ್ರಶ್ನೆ 0 ವಿಮರ್ಶೆ ಸ್ವಾಗತ.

8
00:00:18,780 --> 00:00:23,020
ಅರಿವಾಯಿತು ಇರುವವರು ನಿಮ್ಮ ಈ
ಇನ್ನೂ, ನೀವು ಬುಧವಾರ ಒಂದು ಪ್ರಶ್ನೆ ಹೊಂದಿವೆ.

9
00:00:23,020 --> 00:00:25,700
ಓ-ಹೋ.

10
00:00:25,700 --> 00:00:29,780
>> ನೀವು ಇನ್ನೂ ಅಧ್ಯಯನ ಆರಂಭಿಸಿದರು ಇದ್ದರೆ ಅಥವಾ
ಈ ಇನ್ನೂ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಅರಿವಾಯಿತು ಮಾಡಿಲ್ಲ,

11
00:00:29,780 --> 00:00:34,070
ಕಳೆದ ಕ್ವಿಸ್ ಮತ್ತು ಬಗ್ಗೆ ಎಲ್ಲಾ ಮಾಹಿತಿ
ನಿಮ್ಮ ರಸಪ್ರಶ್ನೆ cs50.net/quizzes ಇರುತ್ತವೆ.

12
00:00:34,070 --> 00:00:38,090
ಒಳ್ಳೆಯ ಸಂಗತಿಗಳನ್ನು ಮೇಲೆ ಇಲ್ಲ,
10 ಕಳೆದ ಹಿಂದಿನ ಕ್ವಿಸ್

13
00:00:38,090 --> 00:00:43,760
ವರ್ಷಗಳ ಹಾಗೂ ಮಾಹಿತಿ
ಈ ರಸಪ್ರಶ್ನೆ ಮತ್ತು ವಿಷಯಗಳ ಬಗ್ಗೆ

14
00:00:43,760 --> 00:00:46,250
ಆ ವ್ಯಾಪ್ತಿಗೆ ಒಳಪಡುತ್ತಾರೆ.

15
00:00:46,250 --> 00:00:48,980
ಆದ್ದರಿಂದ ಅವರ ಪ್ರಾರಂಭಿಸಲು ಅವಕಾಶ.

16
00:00:48,980 --> 00:00:54,240
>> ಆದ್ದರಿಂದ ನೀವು ಹುಡುಗರಿಗೆ, ಮೊದಲ ನೆನಪು
ವರ್ಗ ದಾವೀದನ ದಿನ ಆ ದೀಪಗಳನ್ನು ಮೇಲೆ.

17
00:00:54,240 --> 00:00:59,650
ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ಎಲ್ಲವೂ ಹೋಗುತ್ತದೆ
ಕಂಪ್ಯೂಟರ್ ಬಾನೆಟ್ ಹೊಂದಿದೆ ಅಡಿಯಲ್ಲಿ

18
00:00:59,650 --> 00:01:00,860
ಅವಳಿ ಮಾಡಲಾಗುತ್ತದೆ.

19
00:01:00,860 --> 00:01:04,080
ಬೈನರಿ ಇದು ಶಬ್ದಗಳನ್ನು ಅರ್ಥ
ಹಾಗೆ, 0 ಮತ್ತು 1 ರ.

20
00:01:04,080 --> 00:01:09,290
ಇದು ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ
ನಿರೂಪಿಸಬಹುದು.

21
00:01:09,290 --> 00:01:14,675
>> ಆದ್ದರಿಂದ ಕೇವಲ ವಿಭಾಗದಲ್ಲಿ ಮೊದಲ ದಿನ ಹಾಗೆ
ಡೇವಿಡ್ ಒಂದು ಬೆಳಕಿನ ಆನ್ ಮಾಡಿದಾಗ

22
00:01:14,675 --> 00:01:21,990
ಬಲ್ಬ್, ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ಪ್ರತಿನಿಧಿಸಲು, ಅಥವಾ 1 ಗೆ
ಅರ್ಥ 0 ನ ಯುಗಳ ಮತ್ತು

23
00:01:21,990 --> 00:01:24,110
1 ನ, ಅಥವಾ ಆಫ್.

24
00:01:24,110 --> 00:01:25,360
ಬೈನರಿ ಬೇಸಿಕ್ಸ್.

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
ಪ್ರತಿ ಸ್ಥಳದಲ್ಲಿ ನಿರೂಪಿಸಲಾಗಿದೆ ಇದೆ
ಬೇಸ್ ಎರಡು.

27
00:01:32,470 --> 00:01:36,260
ಆದ್ದರಿಂದ ನಿಮಗೆ 0 ಗೆ 2 ಸೇರಿಸಲು
1 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ 2.

28
00:01:36,260 --> 00:01:41,970
>> ನಿಮ್ಮ ಬೈನರಿ ಮಾಡುವುದು ಎಂಬುದನ್ನು ಲೆಕ್ಕಹಾಕಲು
ದಶಮಾಂಶ, ನೀವು ಈ ಸಮೀಕರಣದ ಅನುಸರಿಸಿ

29
00:01:41,970 --> 00:01:42,840
ಮಾದರಿ ವಿಷಯ.

30
00:01:42,840 --> 00:01:49,510
ಆ ಸ್ಥಳಗಳಲ್ಲಿ ಯಾವುದೇ ಒಂದು 1 ಹೊಂದಿದ್ದರೆ,
ನೀವು ಅದನ್ನು ಗುಣಿಸಿದಾಗ ಯಾವುದೇ

31
00:01:49,510 --> 00:01:53,820
ಇದು ಬೇಸ್, ಅದನ್ನು ಸೇರಿಸಿ, ಮತ್ತು
ನೀವು ದಶಮಾಂಶ ಪಡೆಯಿರಿ.

32
00:01:53,820 --> 00:01:57,930
ಆದ್ದರಿಂದ ಈ ನೀವು ಲೆಕ್ಕ ಹೇಗೆ
ಅವಳಿ 5.

33
00:01:57,930 --> 00:02:01,400
ಕೇವಲ ನಾವು ಮಾಡುತ್ತಿದ್ದ ಹಾಗೆ
ಕೊನೆಯ ಸ್ಲೈಡ್, ಈ ಹೇಗೆ ನೀವು ಆಗಿದೆ

34
00:02:01,400 --> 00:02:02,650
5 ಮೂಲಕ 1 ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> ಹಾಗೆಯೇ, ನೀವು ಸೇರಿಸಬಹುದು ಇಷ್ಟ ಮತ್ತು
ದಶಮಾಂಶ ನಲ್ಲಿ ಕಳೆಯುವುದು ಅಥವಾ 10 ನೆಲೆಯನ್ನು ಅಥವಾ

37
00:02:09,660 --> 00:02:13,040
ನಿಜವಾಗಿಯೂ ಯಾವುದೇ ಪಾದದಲ್ಲಿ ಸೇರಿಸಬಹುದು
ಮತ್ತು ಅವಳಿ ಕಳೆಯಿರಿ.

38
00:02:13,040 --> 00:02:18,400
ನೀವು ನೀವು ನಿರೀಕ್ಷಿಸುವಂತೆ ನಿಖರವಾಗಿ
ಇದು ಹೆಚ್ಚಿನ ಸಮನಾಗಿರುತ್ತದೆ, ಎರಡು ಸೇರಿಸಬಹುದು

39
00:02:18,400 --> 00:02:24,220
1 ಹೆಚ್ಚು, ನೀವು 1, ಇದು 0 ಮಾಡಲು ಸಾಗಿಸುವ,
ಮತ್ತು ಕೇವಲ, ಜೊತೆಗೆ ಆ ರೀತಿ

40
00:02:24,220 --> 00:02:29,910
ನಿಮಗೆ ಸಾಮಾನ್ಯ ನಿರೀಕ್ಷಿಸುವಂತೆ
ದಶಮಾಂಶ ಅಥವಾ ಯಾವುದೇ ಇತರ ಬೇಸ್.

41
00:02:29,910 --> 00:02:30,970
ಕೂಲ್.

42
00:02:30,970 --> 00:02:35,140
>> ನಾನು, ಎಲ್ಲವನ್ನೂ ಮೊದಲು ಹೇಳಿದ ಹಾಗೆ ಆ
ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಹುಡ್ ಅಡಿಯಲ್ಲಿ ಹೋಗುತ್ತದೆ

43
00:02:35,140 --> 00:02:37,560
0 ಮತ್ತು 1 ರ, ಅಥವಾ ಅವಳಿ ಮಾಡಲಾಗುತ್ತದೆ.

44
00:02:37,560 --> 00:02:43,470
ನಾವು ವ್ಯಕ್ತಪಡಿಸಲು ಹೇಗೆ, ಉದಾಹರಣೆಗೆ,
ಅಕ್ಷರಗಳು, ಅಥವಾ ಸಂಖ್ಯೆಗಳು, ಅಥವಾ ಪಾತ್ರಗಳು?

45
00:02:43,470 --> 00:02:45,560
ಆ ಉತ್ತರವನ್ನು ಮಾಡಿದ ASCII ಆಗಿದೆ.

46
00:02:45,560 --> 00:02:49,380
>> ASCII ಅಕ್ಷರಗಳನ್ನು ನಡುವಿನ ಮ್ಯಾಪಿಂಗ್ ಆಗಿದೆ
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಕಾಣುವ ಎಂದು

47
00:02:49,380 --> 00:02:53,360
ಒಂದು ತಂದೆಯ, ಬಿ ನ ಇಂಗ್ಲೀಷ್ ಭಾಷೆಯ,
ಸಿ ಒತ್ತಿಹೇಳುತ್ತವೆ, ಗೆರೆಗಳು, ಮತ್ತು

48
00:02:53,360 --> 00:02:54,910
ಹಾಗೆ ಏನು.

49
00:02:54,910 --> 00:02:57,260
ಹಾಗೂ ಅದು ಒಂದು ASCII ಮೌಲ್ಯವನ್ನು ನಕ್ಷೆಗಳು.

50
00:02:57,260 --> 00:03:03,080
ಒಂದು ASCII ಮೌಲ್ಯವನ್ನು ಕೇವಲ ಒಂದು ಸಂಖ್ಯೆ ಎಂದು
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಮೂಲಕ ತಿಳಿಯಬಹುದು.

51
00:03:03,080 --> 00:03:07,430
ಮತ್ತು ನೀವು ಜೊತೆಗೆ ಮಾಡಬಹುದು ಕೇವಲ ಹಾಗೆ ಮತ್ತು
ಸಂಖ್ಯೆಯ ವ್ಯವಕಲನ, ನೀವು ಮಾಡಬಹುದು

52
00:03:07,430 --> 00:03:10,890
ASCII ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಅವುಗಳನ್ನು.

53
00:03:10,890 --> 00:03:14,050
>> , ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಹಾಗಾಗಿ
ಈ ಮುದ್ರಿಸುತ್ತದೆ?

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
ಹೌದು, ಆದ್ದರಿಂದ ಕೇವಲ ಒಂದು ಜಾಗವನ್ನು ಬಿ ಜಾಗವನ್ನು ಸಿ ಜಾಗವನ್ನು
ಡಿ ಎಲ್ಲಿ ನನ್ನ ಮೌಸ್ ಹೋಗಿವೆ?

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
ನೀವು 65 ಇಂಟ್ ರೂಪಿಸಬಹುದು ಗಮನಿಸಿ.

58
00:03:43,380 --> 00:03:47,080
ಮತ್ತು ನೀವು ಬಳಸುವ ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ
ಶೇಕಡಾ ಸಿ, ಇದು ಒಂದು ಎಂದು ಎಂದು ಅರ್ಥೈಸಲು ಮಾಡುತ್ತೇವೆ

59
00:03:47,080 --> 00:03:49,330
ಪಾತ್ರ ಮತ್ತು ಎ ಮುದ್ರಿಸುತ್ತದೆ

60
00:03:49,330 --> 00:03:52,800
>> ಹಾಗೆಯೇ, ನೀವು ಘೋಷಿಸಬಹುದು
ಇದು ಚಾರ್ ಎಂದು.

61
00:03:52,800 --> 00:03:56,860
ಮತ್ತು ನೀವು ರಷ್ಟು ಬಳಸಿ ಇದು ಮುದ್ರಿಸುತ್ತದೆ
ಸಿ, ಅದು ಎಂದು ಅರ್ಥೈಸಲು ಮಾಡುತ್ತೇವೆ

62
00:03:56,860 --> 00:04:05,240
ಶೇಕಡಾ ಡಿ ಮತ್ತು ನೀವು ಸೇರಿಸಬಹುದು ಕೇವಲ ಹಾಗೆ
ಸಂಖ್ಯೆ, ನೀವು ಪಾತ್ರಗಳು ಸೇರಿಸಬಹುದು

63
00:04:05,240 --> 00:04:06,878
ಈ ಸಂದರ್ಭದಲ್ಲಿ ASCII ಮೌಲ್ಯಗಳನ್ನು,.

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಪಾಯಿಂಟರ್.

66
00:04:16,130 --> 00:04:19,610
5, ಸ್ಟ್ರಿಂಗ್ ಎಂದು, ಮಾಡುವುದಿಲ್ಲ
ವಾಸ್ತವವಾಗಿ 5 ಸಮನಾಗಿರಬೇಕು.

67
00:04:19,610 --> 00:04:26,610
ನಾವು ಹೇಗೆ ಪರಿವರ್ತಿಸಲು ಇರಬಹುದು
ಪೂರ್ಣಾಂಕ 5 ಸ್ಟ್ರಿಂಗ್ 5?

68
00:04:26,610 --> 00:04:28,930
ಯಾವುದೇ ವಿಚಾರಗಳನ್ನು?

69
00:04:28,930 --> 00:04:31,630
ಹೌದು.

70
00:04:31,630 --> 00:04:36,720
>> ನಾವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಎಂದು 5 ಹೊಂದಿದ್ದರೆ,
ನಾವು 0 ಕಳೆಯಬಹುದು.

71
00:04:36,720 --> 00:04:37,820
ಮತ್ತು ನಮಗೆ 5 ನೀಡುತ್ತೇನೆ.

72
00:04:37,820 --> 00:04:41,670
ಮತ್ತು ಹಾಗೆಯೇ, ನಾವು ಒಂದು 5 ಹೊಂದಿದ್ದರೆ
ಪೂರ್ಣಾಂಕ, ಸ್ಟ್ರಿಂಗ್ 0 ಆ ಸೇರಿಸಿ.

73
00:04:41,670 --> 00:04:43,112
ಮತ್ತು ನಮಗೆ ಸ್ಟ್ರಿಂಗ್ 5 ನೀಡುತ್ತದೆ.

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
ಕೂಲ್.

76
00:04:48,350 --> 00:04:52,940
>> ಈಗ, ಒಂದು ಅಲ್ಲಿ ಉಪನ್ಯಾಸ ಮತ್ತೆ ನೆನಪಿಸಿಕೊಂಡು
ಕ್ರಮಾವಳಿಗಳನ್ನು ಕುರಿತು.

77
00:04:52,940 --> 00:04:57,260
ನಾವು ನಿಜವಾಗಿ ಒಂದು ಕಂಪ್ಯೂಟರ್ ಬಯಸುತ್ತೀರಿ ಹೇಗೆ
ಆಸಕ್ತಿದಾಯಕ ವಿಷಯಗಳನ್ನು?

78
00:04:57,260 --> 00:05:00,460
ನೀವು ಸೇರಿಸಿ ಕಳೆದಾಗ, ಗೊತ್ತು
ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಮುದ್ರಣ ಕಾಣುವುದು ಅಲ್ಲ

79
00:05:00,460 --> 00:05:01,730
ಅತ್ಯಾಕರ್ಷಕ.

80
00:05:01,730 --> 00:05:04,620
ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ನಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಬಯಸುವ
ಅಲ್ಗಾರಿದಮ್ ರೀತಿಯ ನಿರ್ವಹಿಸಲು.

81
00:05:04,620 --> 00:05:07,820
ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ ಏನೋ
ಕೇವಲ ಸರಳ ಅಂಕಗಣಿತದ ಹೆಚ್ಚು.

82
00:05:07,820 --> 00:05:11,930
>> ಒಂದು ಕ್ರಮಾವಳಿ ಹಂತದ ಗುಂಪಿನ ಕೇವಲ ಒಂದು ಹೆಜ್ಜೆ
ಮಾಡಲು ಹೇಗೆ ಸೂಚನೆಗಳ

83
00:05:11,930 --> 00:05:14,640
ನಿರ್ದಿಷ್ಟ task--

84
00:05:14,640 --> 00:05:15,660
ಕೇವಲ ಒಂದು ಪಾಕವಿಧಾನವನ್ನು ಇಷ್ಟ.

85
00:05:15,660 --> 00:05:19,990
ನೀವು ಮೊದಲ ದಿನ ನೆನಪು
ಡೇವಿಡ್ ನಮಗೆ ಒಂದು ಕೊಠಡಿ ಎಣಿಕೆ ಮಾಡಿದ್ದ ವರ್ಗ

86
00:05:19,990 --> 00:05:22,550
ಜನರ ಮತ್ತು ಎಷ್ಟು ಜನರು
ಕೊಠಡಿ ಇತ್ತು.

87
00:05:22,550 --> 00:05:24,480
ನೀವು ಎಣಿಸುವ ಸೂಚಿಸಲು ಬಳಸಬಹುದು
ಒಂದೊಂದಾಗಿ.

88
00:05:24,480 --> 00:05:25,860
1, 2, 3, 4.

89
00:05:25,860 --> 00:05:28,010
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ರೇಖೀಯ ಸಮಯದಲ್ಲಿ ಕ್ರಮಾವಳಿ.

90
00:05:28,010 --> 00:05:31,710
>> ಆದರೆ ಡೇವಿಡ್ ಒಂದು ಕ್ರಮಾವಳಿ ಪರಿಚಯಿಸಿತು
ನೀವು ಕೋಣೆಯಲ್ಲಿ ಜನರನ್ನು ಲೆಕ್ಕ

91
00:05:31,710 --> 00:05:37,340
ಎಲ್ಲರಿಗೂ ಅಪ್ ನಿಲ್ಲುತ್ತದೆ, ನಿಮ್ಮ ಹೇಳಲು
ವ್ಯಕ್ತಿಗೆ ಸಂಖ್ಯೆಯ ಸೇರಿಸಲು

92
00:05:37,340 --> 00:05:39,200
ಸಂಖ್ಯೆಯನ್ನು, ಮತ್ತು ಒಂದು ವ್ಯಕ್ತಿ ಕೆಳಗೆ ಕುಳಿತುಕೊಳ್ಳುತ್ತಾನೆ.

93
00:05:39,200 --> 00:05:40,410
ಮತ್ತು ನೀವು ಮತ್ತೆ.

94
00:05:40,410 --> 00:05:42,910
ಆ ಕ್ರಮಾವಳಿಯ ಒಂದು ರೀತಿಯ ಇಲ್ಲಿದೆ.

95
00:05:42,910 --> 00:05:47,520
ನಾವು ಎಷ್ಟು ಪರಿಣಾಮಕಾರಿ ಒಂದು ವಿಶ್ಲೇಷಿಸಬಹುದಾಗಿದೆ
ಇದು ಸಮಯ ಔಟ್ ಮೇಲೆ ಅಲ್ಗಾರಿದಮ್ ಆಧರಿಸಿದೆ.

96
00:05:47,520 --> 00:05:49,680
ಆದರೆ ನಾವು ಸ್ವಲ್ಪ ಮಾತನಾಡಲು ಮಾಡುತ್ತೇವೆ
ಆ ನಂತರ ಬಗ್ಗೆ ಹೆಚ್ಚು.

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಕ್ರಮಾವಳಿಗಳು ಮಾಡಬಹುದು
ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಬರೆಯಬಹುದು.

99
00:05:57,090 --> 00:06:01,120
ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಕೇವಲ ಹಾಗೆ ಒಂದು ಇಂಗ್ಲೀಷ್
ವಾಕ್ಯ ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ

100
00:06:01,120 --> 00:06:02,420
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ.

101
00:06:02,420 --> 00:06:06,070
ಉದಾಹರಣೆಗೆ, ಒಂದು ಬಳಕೆದಾರ ನಾವು ಬಯಸಿದರೆ ಕೇಳಲು
ನನ್ನ ನೆಚ್ಚಿನ ಸಂಖ್ಯೆ ಊಹೆ, ನಾವು

102
00:06:06,070 --> 00:06:08,390
ಉದಾಹರಣೆಗೆ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಹೊಂದಿರಬಹುದು.

103
00:06:08,390 --> 00:06:09,850
>> ಒಂದು ಬಳಕೆದಾರರು ಊಹೆ ಪಡೆಯಿರಿ.

104
00:06:09,850 --> 00:06:13,570
ಊಹೆ ಸರಿಯಾಗಿದ್ದರೆ, ತಿಳಿಸಿ
ಸರಿಯಾದ ಕೋರುತ್ತೇವೆ, ಬೇರೆ ತಿಳಿಸಿ

105
00:06:13,570 --> 00:06:15,560
ಅವರು ಸರಿಯಾದ ಅಲ್ಲ.

106
00:06:15,560 --> 00:06:22,530
ಮತ್ತು ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಸುಲಭವಾಗಿ ಒಂದು ದಾರಿ
ಒಂದು ಕಲ್ಪನೆ ಅಥವಾ ಒಂದು ಕ್ರಮಾವಳಿ ಪ್ರತಿನಿಧಿಸುವ.

107
00:06:22,530 --> 00:06:26,910
ಈಗ ನಾವು ವಾಸ್ತವವಾಗಿ ಬರೆಯಲು ಬಯಸಬಹುದು
ಈ ಭಾಷೆಯಲ್ಲಿ ಕಂಪ್ಯೂಟರ್

108
00:06:26,910 --> 00:06:27,980
ಅರ್ಥ ಮಾಡಬಹುದು.

109
00:06:27,980 --> 00:06:35,660
ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಬರೆಯಬಹುದಾದರೆ
ಮೂಲ ಕೋಡ್ ಎಂದು ಅರ್ಥೈಸುತ್ತಾರೆ.

110
00:06:35,660 --> 00:06:41,320
>> ಇಲ್ಲಿಯವರೆಗೆ, ಮೂಲ ಕೋಡ್ ಪಾಲಿಸಬೇಕು
ನಿರ್ದಿಷ್ಟ ವಾಕ್ಯ

111
00:06:41,320 --> 00:06:42,490
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ.

112
00:06:42,490 --> 00:06:45,430
ಮತ್ತು ಇಲ್ಲಿಯವರೆಗೆ, CS50 ರಲ್ಲಿ, ನಾವು ಮಾಡಿದ
ಹೆಚ್ಚಾಗಿ ಸಿ ಬಳಸಲಾಗುತ್ತಿದೆ.

113
00:06:45,430 --> 00:06:48,320
ಆದ್ದರಿಂದ ಈ ಸಿ ಮೂಲ ಕೋಡ್ ಇರಬಹುದು.

114
00:06:48,320 --> 00:06:51,440
ನಂತರ ಸಹಜವಾಗಿ, ನೀವು ರಾತ್ರಿ ಬಂದು
ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಂಪರ್ಕಕ್ಕೆ

115
00:06:51,440 --> 00:06:52,480
ಪಿಎಚ್ಪಿ ಮುಂತಾದ ಭಾಷೆಗಳಲ್ಲಿ.

116
00:06:52,480 --> 00:06:57,540
ಅಥವಾ ನೀವು ಸಹ, ನೀವು ಇತರ ತರಗತಿಗಳು ತೆಗೆದುಕೊಂಡು
ಜಾವಾ, ಪೈಥಾನ್, ಅಥವಾ OCML ಇರಬಹುದು.

117
00:06:57,540 --> 00:07:01,570
ಆದರೆ ನಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಭಾಷೆಯಲ್ಲಿ, ಇದು
ನಾವು ಮೂಲ ಕೋಡ್ ಬರೆಯಲು ಎಂಬುದರ

118
00:07:01,570 --> 00:07:04,760
ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಅಲ್ಗಾರಿದಮ್ ಎಂದು
ನಾನು ಮೊದಲು ತಿಳಿಸಿದ.

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> ಆದ್ದರಿಂದ ಹೇಗೆ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ವಾಸ್ತವವಾಗಿ ಮಾಡುತ್ತದೆ
ಎಂದು ಅರ್ಥ?

121
00:07:11,430 --> 00:07:14,490
ನಾನು ಆಗಷ್ಟೇ, ಇದು ಮೊದಲು ಹೇಳಿದ ಹಾಗೆ
ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಅರ್ಥ.

122
00:07:14,490 --> 00:07:17,880
ಆದ್ದರಿಂದ ಹೇಗೆ ಮೂಲದಿಂದ ಪಡೆಯಲು
ಎಂದು ಕೆಲಸಕ್ಕೆ ಕೋಡ್

123
00:07:17,880 --> 00:07:18,960
ಅರ್ಥ?

124
00:07:18,960 --> 00:07:22,920
ಹಾಗೆಯೇ, ನಾವು ಏನಾದರೂ
ಒಂದು ಕಂಪೈಲರ್ ಕರೆಯಲಾಗುತ್ತದೆ.

125
00:07:22,920 --> 00:07:28,450
>> ನೀವು ಅತ್ಯಂತ ಮತ್ತೆ ನೆನಪಿಗೆ ವೇಳೆ ನಿಮ್ಮ
psets, ನೀವು ಪ್ರೋಗ್ರಾಂ ರೀತಿಯ ಹೊಂದಿತ್ತು

126
00:07:28,450 --> 00:07:30,370
ಒಂದು ಡಾಟ್ ಸಿ ಕಡತ ಬರೆಯಲಾಗಿದೆ.

127
00:07:30,370 --> 00:07:32,550
ತದನಂತರ ನೀವು ಮಾಡಲು ಟೈಪ್ ಎಂದು.

128
00:07:32,550 --> 00:07:35,970
ಹಾಗಾಗಿ ಮಾಡಲು ಮಾಡುತ್ತಿರುವ?

129
00:07:35,970 --> 00:07:39,970
>> ನೀವು ಕಂಪೈಲ್ ಮಾಡಲು ಟೈಪ್ ಮಾಡಬಹುದು ನಿಮ್ಮ
ಪ್ರೋಗ್ರಾಂ someone-- ಕಾರಣ

130
00:07:39,970 --> 00:07:42,730
ಯಾರು ನಿಮ್ಮ ಪು ಹೊಂದಿಸುತ್ತದೆ ಬರೆದ;
ಬಹುಶಃ David--

131
00:07:42,730 --> 00:07:44,190
ಒಂದು ರೀತಿಯ ಕಡತ ದಾಖಲಿಸಿದವರು.

132
00:07:44,190 --> 00:07:51,320
ಮತ್ತು ಔಟ್ ತಿಳಿಯಲು ಮಾಡಲು ಹೇಳುತ್ತದೆ ನಿಮ್ಮ
ಕಂಪೈಲರ್, ಎಂದು ಖಣಿಲು, ಚಿತ್ತವನ್ನು

133
00:07:51,320 --> 00:07:55,560
ನಂತರ ವಸ್ತು ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಕಂಪೈಲ್
ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಇದು ಕೋಡ್,

134
00:07:55,560 --> 00:07:57,720
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅರ್ಥ.

135
00:07:57,720 --> 00:08:01,610
ಆದರೆ ಸ್ವಲ್ಪ ನಂತರ, ನಾವು ಹೋಗಿ
ಸಂಕಲನಕಾರರ ಬಗ್ಗೆ ಹೆಚ್ಚು ಆಳವಾದ.

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> ಆದ್ದರಿಂದ, ಮರುಪಡೆಯಲು, pset 0, where-- ಹೌದು,
ಪ್ರಶ್ನೆ?

138
00:08:10,800 --> 00:08:11,620
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

139
00:08:11,620 --> 00:08:12,490
>> ಸ್ಪೀಕರ್ 1: ಹೌದು.

140
00:08:12,490 --> 00:08:14,960
ನಾನು ಅವರು ಯೋಚಿಸುವುದಿಲ್ಲ
ಆನ್ಲೈನ್ ಇರಬೇಕು.

141
00:08:14,960 --> 00:08:15,120
ಹೌದು.

142
00:08:15,120 --> 00:08:16,572
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ] ಹಾಗೆ?

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> ಸ್ಪೀಕರ್ 1: ಇದು ಅಲ್ಲ.

145
00:08:20,830 --> 00:08:25,810
ದಿ cs50.net/quizzes ಇರುತ್ತವೆ.

146
00:08:25,810 --> 00:08:32,900
>> ಪ್ರೇಕ್ಷಕರು: ಸ್ಲಾಶ್ ಕ್ವಿಸ್, 2013 ಕಡಿದು
0 ಕಡಿದು, ಮತ್ತು ಕೇವಲ ಮೂಲಕ ಕ್ಲಿಕ್

147
00:08:32,900 --> 00:08:35,956
ಕ್ವಿಸ್ 2013 ಮತ್ತು ರಸಪ್ರಶ್ನೆ 0,
ವಿಭಾಗ ಸ್ಲೈಡ್ಗಳು ಪರಿಶೀಲಿಸಿ.

148
00:08:35,956 --> 00:08:40,380
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಆದ್ದರಿಂದ ನೀವು ಹುಡುಗರಿಗೆ ಬಯಸಿದರೆ
ಅದನ್ನು ಎಳೆಯಲು ಮತ್ತು ಅದನ್ನು ನೋಡಲು ನಿಮ್ಮ

149
00:08:40,380 --> 00:08:42,740
ಕಂಪ್ಯೂಟರಿನಲ್ಲಿ, ತುಂಬಾ ಉತ್ತಮ ಇಲ್ಲಿದೆ.

150
00:08:42,740 --> 00:08:43,130
ಮತ್ತೆ ಹೇಳುತ್ತಾರೆ.

151
00:08:43,130 --> 00:08:44,546
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

152
00:08:44,546 --> 00:08:48,780
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, [ಕೇಳಿಸುವುದಿಲ್ಲ]
ನಕಲಿ ಅಸ್ಥಿರವಾಗಿದೆ.

153
00:08:48,780 --> 00:08:49,644
ಹೌದು, ಓ?

154
00:08:49,644 --> 00:08:51,372
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

155
00:08:51,372 --> 00:08:54,300
>> ಸ್ಪೀಕರ್ 1: ಇಲ್ಲ, ಸ್ಟ್ರೈಕ್
ಪರೀಕ್ಷೆಯಲ್ಲಿ ಅಲ್ಲ.

156
00:08:54,300 --> 00:08:55,950
ಕ್ಷಮಿಸಿ, ಅವಳ ಪ್ರಶ್ನೆ
ಪರೀಕ್ಷೆಯಲ್ಲಿ ಸ್ಟ್ರೈಕ್.

157
00:08:55,950 --> 00:08:59,530
ಇದು ಅಲ್ಲ.

158
00:08:59,530 --> 00:09:05,780
ಆದ್ದರಿಂದ pset 0, ನೀವು ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ಇರಬೇಕು
ತೀರ ಬಳಸಿ ಏನಾದರೂ ಜಾರಿಗೆ.

159
00:09:05,780 --> 00:09:13,100
ಮತ್ತು ನಾವು ಕೆಲವು ಮೂಲಭೂತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕಲಿತ
ತೀರ ಬಳಸಿ ಅಂಶಗಳಾಗಿವೆ.

160
00:09:13,100 --> 00:09:15,590
>> ಈ ಕೆಲವು ಒಂದು ಅವಲೋಕಿಸೋಣ
ಈ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್ಸ್

161
00:09:15,590 --> 00:09:18,170
ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅಪ್ ಮಾಡಿ.

162
00:09:18,170 --> 00:09:20,570
ಮೊದಲ ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿ.

163
00:09:20,570 --> 00:09:24,540
ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳು ಇವನ್ನು
ಹೊಂದಿರುವ 0 ಅಥವಾ ಏನು

164
00:09:24,540 --> 00:09:25,700
ಎರಡು ಸಾಧ್ಯವಿರುವ ಮೌಲ್ಯಗಳು.

165
00:09:25,700 --> 00:09:30,320
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸರಿ ಅಥವಾ ತಪ್ಪು,
ಆನ್ ಅಥವಾ ಆಫ್, ಮತ್ತು ಹೌದು ಅಥವಾ ಇಲ್ಲ.

166
00:09:30,320 --> 00:09:35,390
ಸರಳ, ಸರಳ ಒಂದು ಉದಾಹರಣೆಯೆಂದರೆ,
ಒಂದು ಬೂಲಿಯನ್ ಬಳಸುವ ಪ್ರೋಗ್ರಾಂ

167
00:09:35,390 --> 00:09:39,140
ಇಲ್ಲಿ ಅಭಿವ್ಯಕ್ತಿ ಅಪ್.

168
00:09:39,140 --> 00:09:43,220
>> ಆದ್ದರಿಂದ ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳು ಕಾಣಿಸಕೊಳ್ಳಬೇಕೆಂದರೆ
ಉಪಯುಕ್ತ, ನಾವು ಬೂಲಿಯನ್ ನಿರ್ವಾಹಕರು ಹೊಂದಿವೆ.

169
00:09:43,220 --> 00:09:48,920
ಈ ಬಳಸಬಹುದಾದ ನಿರ್ವಾಹಕರು
ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸಿ.

170
00:09:48,920 --> 00:09:52,820
ನಾವು ಮತ್ತು ಅಥವಾ ಸಮ, ಕಡಿಮೆ
ಹೆಚ್ಚು ಅಥವಾ ಹೆಚ್ಚಿನ ಗೆ ಸಮನಾಗಿರಬೇಕು

171
00:09:52,820 --> 00:09:55,130
ಸಮಾನವಾಗಿರುತ್ತದೆ, ಮತ್ತು ಕಡಿಮೆ
ಹೆಚ್ಚು ಅಥವಾ ಹೆಚ್ಚಿನ.

172
00:09:55,130 --> 00:09:59,060
ಆದರೆ ಈ ನಿರ್ವಾಹಕರು ಉಪಯುಕ್ತ ಅಲ್ಲ
ನಾವು ಸಂಯೋಜಿಸಲಾಗಿರುವ ಹೊರತು

173
00:09:59,060 --> 00:10:00,320
ನಿಯಮಗಳು.

174
00:10:00,320 --> 00:10:04,370
>> ಆದ್ದರಿಂದ ನೀವು ಹುಡುಗರಿಗೆ ಆರಂಭದಿಂದ ನೆನಪು
ನಿಮ್ಮ ಪು ನಾವು ಹೊಂದಿಸುತ್ತದೆ

175
00:10:04,370 --> 00:10:05,400
ಪರಿಸ್ಥಿತಿಗಳು.

176
00:10:05,400 --> 00:10:09,710
ಅವರು ಸಲಾಕೆಗಳನ್ನು ನಂತಹ ಮೂಲಭೂತವಾಗಿ, ಅವು
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ತರ್ಕ ಎಂದು

177
00:10:09,710 --> 00:10:12,670
ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ಕಾರ್ಯಗತಗೊಳಿಸಿ
ಒಂದು ಸ್ಥಿತಿಯನ್ನು ಭೇಟಿ.

178
00:10:12,670 --> 00:10:18,150
ನಾವು ಎಂದು ಪರಿಸ್ಥಿತಿಗಳ ಆದ್ದರಿಂದ ಒಂದು
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅನೇಕ ಬಾರಿ ಬಳಸಲಾಗುತ್ತದೆ

179
00:10:18,150 --> 00:10:21,470
ಬೇರೆ, ವೇಳೆ, ಮತ್ತು ಬೇರೆ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ, ವೇಳೆ.

180
00:10:21,470 --> 00:10:24,060
>> ಇಲ್ಲಿ ಹೇಗೆ ಒಂದು ಉದಾಹರಣೆ
ನೀವು ಬಳಸಬಹುದು.

181
00:10:24,060 --> 00:10:28,430
ಯಾರಾದರೂ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ತಿಳಿದಿದೆಯೇ
ಕೇವಲ ಹೇಳಿಕೆಗಳನ್ನು ವೇಳೆ ಬಳಸಿ

182
00:10:28,430 --> 00:10:32,530
ವೇಳೆ, ಬೇರೆ ಪದ್ಯಗಳನ್ನು ಕೆಳಗೆ ರೀತಿಯಲ್ಲಿ,
ವೇಳೆ, ಮತ್ತು ಬೇರೆ ಸೇರಿಕೊಂಡು?

183
00:10:32,530 --> 00:10:33,013
ಹೌದು?

184
00:10:33,013 --> 00:10:34,263
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> ಸ್ಪೀಕರ್ 1: ನಿಖರವಾಗಿ.

187
00:10:42,160 --> 00:10:50,210
ಹಾಗಾಗಿ ವೇಳೆ ವೇಳೆ ಈ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲೂ
ರೀತಿಯಲ್ಲಿ, ಈ ಸ್ಥಿತಿಯನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ

188
00:10:50,210 --> 00:10:52,800
ನಿಜ, ಇದು ಇನ್ನೂ ಮುಂದುವರಿಯುತ್ತದೆ
ಮುಂದಿನ ಎರಡು ಪರೀಕ್ಷೆ.

189
00:10:52,800 --> 00:11:00,120
, ಆದರೆ ಒಂದು ಬೇರೆ-ವೇಳೆ, ಒಂದು ಬೇರೆ ಜೊತೆ
ಹೇಳಿಕೆ, ಒಂದು ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ,

190
00:11:00,120 --> 00:11:02,640
ಇತರರು ಪರೀಕ್ಷಿಸಲಾಯಿತು.

191
00:11:02,640 --> 00:11:05,955
ಆ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು?

192
00:11:05,955 --> 00:11:06,890
ಕೂಲ್.

193
00:11:06,890 --> 00:11:12,240
>> ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಬೇರೆ ಒಂದು ವೇಳೆ-ಬೇರೆ ಬಳಸಲು
ನೀವು ತಿಳಿದಿದ್ದರೆ ಹೇಳಿಕೆ ಇದು ಕೇವಲ ಮಾಡಬಹುದು

194
00:11:12,240 --> 00:11:14,470
ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಎಂದು.

195
00:11:14,470 --> 00:11:21,550
ಎಕ್ಸ್ ಕಡಿಮೆ 0 ಆದ್ದರಿಂದ ವೇಳೆ ನಾವು, ಗೊತ್ತಿಲ್ಲ
ಖಂಡಿತವಾಗಿಯೂ ಹಿಂದಿರುಗಬಹುದೆಂದು

196
00:11:21,550 --> 00:11:22,890
0 ಹೆಚ್ಚು.

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> ಮುಂದೆ, ಮತ್ತೊಂದು ಬ್ಲಾಕ್ ನಿರ್ಮಾಣ
ನಾವು ಕಲಿತ ಎಂದು ಲೂಪ್ ಗಳು.

199
00:11:31,480 --> 00:11:33,310
ನಾವು ಕುಣಿಕೆಗಳು ಮೂರು ವಿಧದ ಹೊಂದಿವೆ.

200
00:11:33,310 --> 00:11:35,830
ಕುಣಿಕೆಗಳು, ಲೂಪ್ ಮಾಡುವಾಗ,
ಮತ್ತು ಸೇರಿರುವ ಸಮಯದಲ್ಲೂ.

201
00:11:35,830 --> 00:11:38,730
ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ, ನೀವು ಯಾವಾಗ ಕುಳಿತು
ಏನೋ ಬರೆಯಲು, ನೀವು ನಿರ್ಧರಿಸಲು ಹೊಂದಿರುತ್ತವೆ

202
00:11:38,730 --> 00:11:40,060
ನೀವು ಬಳಸಲು ಬಯಸುವ ಮೂರು ಯಾವ.

203
00:11:40,060 --> 00:11:41,900
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಒಂದು ನಿರ್ಧರಿಸುವಿರಿ?

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> ನಾವು ತಿಳಿದಿದ್ದರೆ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಲೂಪ್ ಒಂದು ಬಳಸಿ
ಎಷ್ಟು ಬಾರಿ ನಾವು ಮರಳಿ ಬಯಸುವ

206
00:11:48,790 --> 00:11:53,650
ಏನೋ ಮೂಲಕ ಅಥವಾ ಎಷ್ಟು ಬಾರಿ
ನಾವು ಕಾರ್ಯ ನಿರ್ವಹಿಸಲು ಬಯಸುವ.

207
00:11:53,650 --> 00:11:58,830
ನಾವು ಕೆಲವು ಅಗತ್ಯವಿದ್ದರೆ ನಾವು ಕುಣಿಕೆಗಳು ಮಾಡುವಾಗ ಬಳಸಲು
ಸ್ಥಿತಿ ನಡೆಸಲು ನಿಜವೆಂದು.

208
00:11:58,830 --> 00:12:03,730
ನಾವು ಹೋಲುತ್ತದೆ ಸಮಯದಲ್ಲೂ ಬಳಸಿ
ಆದರೆ, ಆದರೆ ನಾವು ನಮ್ಮ ಕೋಡ್ ನಲ್ಲಿ ಚಲಾಯಿಸಲು ಬಯಸುವ

209
00:12:03,730 --> 00:12:04,880
ಕನಿಷ್ಠ ಒಂದು ಬಾರಿ.

210
00:12:04,880 --> 00:12:09,410
>> ಮಾಡಬೇಡಿ ಏನೇ ಹಾಗೆ ಮಾಡುವಾಗ, ತಿನ್ನುವೆ
ಯಾವಾಗಲೂ ಕನಿಷ್ಟ ಒಂದು ಬಾರಿ ಔಟ್.

211
00:12:09,410 --> 00:12:13,120
, ಆದರೆ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು
ಎಲ್ಲ ಔಟ್ ಇರಬಹುದು

212
00:12:13,120 --> 00:12:15,490
ಸ್ಥಿತಿ ತೃಪ್ತರಾಗಿಲ್ಲ.

213
00:12:15,490 --> 00:12:16,740
ಅದು ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> ಲೂಪ್ ಒಂದು ಆದ್ದರಿಂದ ರಚನೆ.

216
00:12:22,860 --> 00:12:23,620
ನೀವು ಹುಡುಗರಿಗೆ ಈ ನೋಡಿದ್ದೇವೆ.

217
00:12:23,620 --> 00:12:25,320
ನೀವು ಆರಂಭಿಸಲು.

218
00:12:25,320 --> 00:12:26,600
ನೀವು ಸ್ಥಿತಿಯನ್ನು ರೀತಿಯ.

219
00:12:26,600 --> 00:12:32,340
ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ನಾವು ಆರಂಭಿಸಲು ಇರಬಹುದು
ಮಾಹಿತಿ ಇ 0 ಸಮನಾಗಿರುತ್ತದೆ.

220
00:12:32,340 --> 00:12:34,040
ನಾನು 10 ಕಡಿಮೆ ಆಗಿದೆ.

221
00:12:34,040 --> 00:12:35,442
ಮತ್ತು ನಾನು ++.

222
00:12:35,442 --> 00:12:39,010
ನಾವು ಮಾಡಿದ ಅತ್ಯಂತ ಸರಳ ಒಂದು.

223
00:12:39,010 --> 00:12:42,210
>> ಸ್ವಲ್ಪ ಲೂಪ್, ಅದೇ ರೀತಿ, ನೀವು ಹೊಂದಿವೆ
ಆರಂಭಕ್ಕೆ ರೀತಿಯ ಹೊಂದಲು,

224
00:12:42,210 --> 00:12:44,980
ಸ್ಥಿತಿ ರೀತಿಯ, ಮತ್ತು
ಅಪ್ಡೇಟ್ ರೀತಿಯ.

225
00:12:44,980 --> 00:12:51,990
ಆದ್ದರಿಂದ ನಾವು ಲೂಪ್ ನಮ್ಮ ಬಳಸಿಕೊಂಡು
ಸ್ವಲ್ಪ ಲೂಪ್ ಈ ಬಳಸುವ.

226
00:12:51,990 --> 00:12:56,000
ಮತ್ತು ಹಾಗೆಯೇ ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಜೊತೆ,
ನಾವು ಕೆಲವು ಆರಂಭಕ್ಕೆ ಹೊಂದಿರಬಹುದು,

227
00:12:56,000 --> 00:12:58,640
, ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಪ್ಡೇಟ್, ಮತ್ತು
ನಂತರ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ.

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> ಈಗ ಕಾರ್ಯಗಳನ್ನು.

230
00:13:05,140 --> 00:13:06,460
ನಾವು ಒಟ್ಟಿಗೆ ಎಲ್ಲವನ್ನೂ ಪುಟ್.

231
00:13:06,460 --> 00:13:10,140
ನಾವು ಕೆಲವು ಬರೆಯಲು ಬಯಸಬಹುದು
ಕಾರ್ಯ ರೀತಿಯ.

232
00:13:10,140 --> 00:13:12,790
ಸಾಮಾನ್ಯ ಕ್ರಿಯೆ ಎಂದು ನೀವು ಮಾಡಬಹುದು
ಈಗಾಗಲೇ ನೋಡಿದ್ದೇವೆ ಮುಖ್ಯ ಆಗಿದೆ.

233
00:13:12,790 --> 00:13:13,770
ಮುಖ್ಯ ಕ್ರಿಯೆಯಾಗಿದೆ.

234
00:13:13,770 --> 00:13:16,160
ಇದು ರಿಟರ್ನ್ ಪ್ರಕಾರ, ಇಂಟ್ ಹೊಂದಿದೆ.

235
00:13:16,160 --> 00:13:18,470
ಇದು ಮುಖ್ಯ ಕಾರ್ಯ ಹೆಸರನ್ನು ಹೊಂದಿದೆ.

236
00:13:18,470 --> 00:13:20,810
ಮತ್ತು ಇದು ವಾದಗಳನ್ನು argc ಮತ್ತು argv ಹೊಂದಿದೆ.

237
00:13:20,810 --> 00:13:24,040
ಆದ್ದರಿಂದ ಮುಖ್ಯ ಕೇವಲ ಕ್ರಿಯೆಯಾಗಿದೆ.

238
00:13:24,040 --> 00:13:27,230
>> ನೀವು ಬಳಸಿದ ಇರಬಹುದು ಇತರ ಕ್ರಿಯೆಗಳು,
printf-- printf ಒಂದು ಕಾರ್ಯ ಇದೆ

239
00:13:27,230 --> 00:13:29,330
GetInt, toupper.

240
00:13:29,330 --> 00:13:32,010
ಆದರೆ ಈ ಎಂದು ಸಂಭವಿಸಿ
ನಮಗಾಗಿ ಜಾರಿಗೆ

241
00:13:32,010 --> 00:13:33,270
ಗ್ರಂಥಾಲಯದ ರೀತಿಯ.

242
00:13:33,270 --> 00:13:37,400
ನೀವು ಹುಡುಗರಿಗೆ ಸೇರಿದಂತೆ ನೆನಪಿಡಿ
ಈ cs50.h ಗ್ರಂಥಾಲಯ ಅಥವಾ

243
00:13:37,400 --> 00:13:38,510
ಸ್ಟ್ಯಾಂಡರ್ಡ್ I / O lib.

244
00:13:38,510 --> 00:13:39,200
ಹೌದು, ಪ್ರಶ್ನೆ?

245
00:13:39,200 --> 00:13:41,610
>> ಪ್ರೇಕ್ಷಕರು: ಸಿ ಕೇವಲ ಅಂತರ್ಗತ ಮುಖ್ಯ ಈಸ್?

246
00:13:41,610 --> 00:13:44,740
ಇದು ಕೇವಲ ರೀತಿಯ [ಕೇಳಿಸುವುದಿಲ್ಲ] ಡಸ್?

247
00:13:44,740 --> 00:13:47,370
>> ಸ್ಪೀಕರ್ 1: ಪ್ರಶ್ನೆ
ಮುಖ್ಯ ವೇಳೆ ಸಿ ಸ್ವರೂಪ.

248
00:13:47,370 --> 00:13:51,460
ಮತ್ತು ಹೌದು, ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು
ಮುಖ್ಯ ಫಂಕ್ಷನ್.

249
00:13:51,460 --> 00:13:55,290
ಇದು ರೀತಿಯ ಕಂಪ್ಯೂಟರ್ ಆಫ್ ಅನಿವಾರ್ಯವಾಗಿದೆ
ಆರಂಭಿಸಲು ಅಲ್ಲಿ ತಿಳಿಯಲು

250
00:13:55,290 --> 00:13:55,993
ಕೋಡ್ ಚಾಲನೆಯಲ್ಲಿರುವ.

251
00:13:55,993 --> 00:13:58,108
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ಬಯಸುವಿರಾ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

252
00:13:58,108 --> 00:13:59,480
>> ಸ್ಪೀಕರ್ 1: ನಂ

253
00:13:59,480 --> 00:14:00,760
ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
ಕೂಲ್.

256
00:14:04,770 --> 00:14:08,050
ನೀವು ಒಂದು ಕಾರ್ಯ ಬಳಸಬಹುದು ಆದ್ದರಿಂದ ಕೇವಲ,
ನೀವು ಬರೆದ, ನೀವು ಮಾಡಬಹುದು

257
00:14:08,050 --> 00:14:10,380
ನಿಮ್ಮ ಕಾರ್ಯ ಬರೆಯಲು.

258
00:14:10,380 --> 00:14:17,050
ಈ ಯಾರೋ ಇರಬಹುದು ಕ್ರಿಯೆಯಾಗಿದೆ
ಪರಿಮಾಣ ಲೆಕ್ಕ ಬರೆದಿದ್ದಾರೆ

259
00:14:17,050 --> 00:14:18,395
ಉದಾಹರಣೆಗೆ ಒಂದು ಪ್ರಶ್ನೆ, ನ.

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
ರಿಟರ್ನ್ ಪ್ರಕಾರ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇಲ್ಲಿ ಇಲ್ಲ
ಇಂಟ್, ನಮ್ಮ ಕ್ರಿಯೆ ಹೆಸರು ಪ್ರಶ್ನೆ ಮತ್ತು ನಮ್ಮ

262
00:14:29,500 --> 00:14:31,360
ನಿಯತಾಂಕಗಳನ್ನು ಪಟ್ಟಿ.

263
00:14:31,360 --> 00:14:34,550
>> ಮತ್ತು ನೀವು ದಶಮಾಂಶ ಬರೆಯಬೇಕು ಗಮನಿಸಿ
ನೀವು ಬಯಸುವ ನಿಯತಾಂಕ ಮಾದರಿ

264
00:14:34,550 --> 00:14:38,660
ಬಳಸಲು ಅಥವಾ ಕಾರ್ಯವನ್ನು ಮಾಡುವುದಿಲ್ಲ ಬೇರೆ
ಯಾವ ರೀತಿಯ ತಿಳಿಯಲು

265
00:14:38,660 --> 00:14:41,650
ನಿಯತಾಂಕ ನಾನು ಸ್ವೀಕರಿಸುವ ಮಾಡಬೇಕು.

266
00:14:41,650 --> 00:14:48,110
ಆದ್ದರಿಂದ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಬಯಸುವ
ನಮ್ಮ ಇನ್ಪುಟ್ ಒಂದು ಪೂರ್ಣಾಂಕ.

267
00:14:48,110 --> 00:14:50,390
ಆದ್ದರಿಂದ ನಾವು ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು ಬಯಸಬಹುದು?

268
00:14:50,390 --> 00:14:52,800
>> ಎಲ್ಲಾ ಮೊದಲ, ಸಂಸ್ಥೆಗೆ ಉತ್ತಮ.

269
00:14:52,800 --> 00:14:56,350
ಅವರು ನಿಮ್ಮ ಕೋಡ್ ಒಡೆಯಲು ಸಹಾಯ
ಹೆಚ್ಚು ಭಾಗಗಳಲ್ಲಿ ಆಯೋಜಿಸಿ ಮಾಡಲು

270
00:14:56,350 --> 00:14:57,960
ಸುಲಭವಾಗಿ ಓದಲು.

271
00:14:57,960 --> 00:14:59,760
ಸರಳೀಕರಣ.

272
00:14:59,760 --> 00:15:01,740
ಈ ವಿನ್ಯಾಸ ಒಳ್ಳೆಯದು.

273
00:15:01,740 --> 00:15:04,570
ನೀವು ಕೋಡ್ ತುಂಡು ಓದುವ ಮಾಡಿದಾಗ
ಮತ್ತು ಮುಖ್ಯ ಕಾರ್ಯ, ನಿಜಕ್ಕೂ

274
00:15:04,570 --> 00:15:07,750
ನಿಜವಾಗಿಯೂ ಬಹಳ, ಇದು ಕಷ್ಟ ಇರಬಹುದು
ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಬಗ್ಗೆ ಕಾರಣ.

275
00:15:07,750 --> 00:15:11,710
ಆದ್ದರಿಂದ ನೀವು ಕಾರ್ಯಗಳನ್ನು ಅದನ್ನು ಮುರಿಯಲು ವೇಳೆ,
ಇದು ಓದಲು ಸುಲಭ ಇರಬಹುದು.

276
00:15:11,710 --> 00:15:12,750
ಮತ್ತು ಮರುಬಳಕೆ-ಸಾಮರ್ಥ್ಯವನ್ನು.

277
00:15:12,750 --> 00:15:16,940
ನೀವು ಕೋಡ್ ಒಂದು ಪಾಲನ್ನು ಹೊಂದಿದ್ದರೆ ಎನ್ನುವುದನ್ನು
ಎಂಬ ಅಥವಾ ಅನೇಕ ಬಾರಿ ಔಟ್,

278
00:15:16,940 --> 00:15:20,690
ಬದಲಿಗೆ ಆ ಕೋಡ್ 10 ಬಾರಿ ಪುನಃ
ನಿಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯ, ನೀವು ಮಾಡಬಹುದು

279
00:15:20,690 --> 00:15:21,440
ಇದು ಮರುಬಳಕೆ ಬಯಸುವ.

280
00:15:21,440 --> 00:15:25,740
ನಂತರ ಪ್ರತಿ ಬಾರಿ ನೀವು ಬಳಸಬೇಕಾಗುತ್ತದೆ
ಕೋಡ್ ತುಂಡು ಕಾರ್ಯ ಕರೆ.

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> ಈಗ ನಾವು ಗೀರುವುದು ಮತ್ತೆ ನೆನಪು ವೇಳೆ,
ನಾವು, ಕೆಲವು ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಕುರಿತು

283
00:15:35,380 --> 00:15:37,680
ಇದು ಒಂದು ಥ್ರೆಡ್ಡಿಂಗ್ ಇದೆ.

284
00:15:37,680 --> 00:15:41,120
ಥ್ರೆಡ್ ಅನೇಕ ಪರಿಕಲ್ಪನೆಯಾಗಿದೆ
ಕೋಡ್ ಅನುಕ್ರಮವನ್ನು

285
00:15:41,120 --> 00:15:43,040
ಅದೇ ಸಮಯದಲ್ಲಿ ಪಾಲಿಸಲು.

286
00:15:43,040 --> 00:15:47,490
ಆದ್ದರಿಂದ ಡೇವಿಡ್ ಹೊಂದಿದ್ದುದು ದಿನದಿಂದ ಮರಳಿ ಭಾವಿಸಿದರೆ
ನೀವು ಹುಡುಗರಿಗೆ ಸಂಖ್ಯೆ ಆಫ್ ಎಣಿಕೆ

287
00:15:47,490 --> 00:15:48,440
ಕೋಣೆಯಲ್ಲಿ ಜನರು.

288
00:15:48,440 --> 00:15:50,550
>> ಮೂಲಭೂತವಾಗಿ, ಹೊರಟಿದ್ದ
ನೀವು ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ಹೊಂದಿದೆ ಎಂದು

289
00:15:50,550 --> 00:15:52,370
ಪ್ರತ್ಯೇಕ ಎಳೆಗಳನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ.

290
00:15:52,370 --> 00:15:55,540
ಮತ್ತು ಆ ಎಳೆಗಳನ್ನು ಒಟ್ಟಿಗೆ ಬರುವ
ಉತ್ತರವನ್ನು ರೀತಿಯ ಪಡೆಯಲು.

291
00:15:55,540 --> 00:15:58,890
ಹಾಗೆಯೇ, ಸ್ಕ್ರ್ಯಾಚ್ ರಲ್ಲಿ, ನೀವು ಯಾವಾಗ ಹೊಂದಿವೆ
ಅನೇಕ sprites, ನೀವು ಮಾಡಬಹುದು

292
00:15:58,890 --> 00:16:01,070
ಬೆಕ್ಕು ಮತ್ತು ನಾಯಿ.

293
00:16:01,070 --> 00:16:08,770
ಅವರು ಏಕಕಾಲದಲ್ಲಿ ಎಂದು
ತಮ್ಮ ಚಿತ್ರಕಥೆಗಳನ್ನು ಚಾಲನೆಯಲ್ಲಿರುವ.

294
00:16:08,770 --> 00:16:10,020
ಆ ಥ್ರೆಡ್ಡಿಂಗ್ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> ಮತ್ತು ಇತರ ಪರಿಕಲ್ಪನೆ ಎಂದು
ಆರಂಭದಿಂದ ಪರಿಚಯಿಸಲಾಯಿತು ಘಟನೆಗಳು ಆಗಿತ್ತು.

297
00:16:18,000 --> 00:16:22,550
ಮತ್ತು ಘಟನೆಗಳ ಸಂದರ್ಭದಲ್ಲಿ ಅನೇಕ ಭಾಗಗಳು
ನಿಮ್ಮ ಕೋಡ್ ಪರಸ್ಪರ ಸಂವಹನ.

298
00:16:22,550 --> 00:16:26,840
ನೀವು ಬಳಸಿದಾಗ ಸ್ಕ್ರಾಚ್, ಈ ಆಗಿತ್ತು
ಪ್ರಸಾರ ನಿಯಂತ್ರಣ ಮತ್ತು ನಾನು

299
00:16:26,840 --> 00:16:29,500
ಬ್ಲಾಕ್ಗಳನ್ನು ಸ್ವೀಕರಿಸಿ.

300
00:16:29,500 --> 00:16:35,170
>> ಮತ್ತು, ಸಮಸ್ಯೆ ಸೆಟ್ 4, ನಾವು ನೋಡಿದ
ಹಾಗೂ ಘಟನೆಗಳ ಸ್ವಲ್ಪ.

301
00:16:35,170 --> 00:16:38,250
ನೀವು ಹುಡುಗರಿಗೆ ಬಳಸುವ ಸಾಧ್ಯತೆಯಿದೆ
Gevent ಗ್ರಂಥಾಲಯದ.

302
00:16:38,250 --> 00:16:42,450
ಮತ್ತು ಕಾರ್ಯ ಇರಲಿಲ್ಲ waitForClick
ನೀವು ಕಾಯುತ್ತಿದ್ದ

303
00:16:42,450 --> 00:16:44,300
ಬಳಕೆದಾರ ಮಾಡಿ.

304
00:16:44,300 --> 00:16:47,870
ನಿಮ್ಮ ಕ್ಲಿಕ್, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎಂದು
ಕ್ಲಿಕ್ ಕ್ರಿಯೆಯನ್ನು ಮತ್ತು ನಿರೀಕ್ಷಿಸಿ ನಿಮ್ಮ ಆಗಿದೆ

305
00:16:47,870 --> 00:16:49,120
ಈವೆಂಟ್ ಹ್ಯಾಂಡ್ಲರ್.

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> ಮತ್ತು, ನಿಮ್ಮ psets ಉದ್ದಕ್ಕೂ ರನ್ನಿಂಗ್
ಮತ್ತು ನಿಮ್ಮ psets ಕೆಲಸ, ನೀವು

308
00:16:58,630 --> 00:17:01,920
ಸಂಪರ್ಕಕ್ಕೆ ಬಂದಿರಬಹುದು
ಈ ಆಜ್ಞೆಗಳನ್ನು ಕೆಲವು.

309
00:17:01,920 --> 00:17:05,579
ನೀವು ಟೈಪ್ ಏನು ನಿಮ್ಮ
ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಅಥವಾ ಯಾವುದೇ ವಿಂಡೋ

310
00:17:05,579 --> 00:17:12,119
ಆ, ನಿಮ್ಮ ಗ್ರಾಂ ಬದಲಾಯಿಸಿ ಮೇಲೆ ತೋರಿಸುತ್ತದೆ
ಮೂಲಭೂತವಾಗಿ, ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ನ್ಯಾವಿಗೇಟ್.

311
00:17:12,119 --> 00:17:19,440
>> ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ಎಲ್ಎಸ್ ಪಟ್ಟಿ
ಒಂದು ಕೋಶ.

312
00:17:19,440 --> 00:17:22,510
ಕೋಶವನ್ನು ಹೊಸ ಫೋಲ್ಡರ್ ಸೃಷ್ಟಿಸುತ್ತದೆ ಮಾಡಿ.

313
00:17:22,510 --> 00:17:24,819
ಸಿಡಿ, ಬದಲಾವಣೆ ಕೋಶದ.

314
00:17:24,819 --> 00:17:28,400
ಆರ್ಎಮ್, ತೆಗೆದು, ಒಂದು ಕಡತ ಅಳಿಸಿದರೆ
ಅಥವಾ ಕೆಲವು ಕೋಶ.

315
00:17:28,400 --> 00:17:31,050
ನಂತರ ಕೋಶವನ್ನು ತೆಗೆದು
ಒಂದು ಕೋಶವನ್ನು ತೆಗೆದು.

316
00:17:31,050 --> 00:17:32,300
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಖಚಿತವಾಗಿ.

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
ಕ್ಷಮಿಸಿ, ಪ್ರಶ್ನೆಯಾಗಿದೆ ನೀವು
ಈ ಹಾಕುವ ಸೂಚಿಸುವ

321
00:17:46,040 --> 00:17:48,840
ಮೋಸಮಾಡುವುದನ್ನು ಶೀಟ್ ಮೇಲೆ.

322
00:17:48,840 --> 00:17:49,440
ಇದು ಸಹಾಯ.

323
00:17:49,440 --> 00:17:51,490
ನೀವು ಕೊಠಡಿ ಹೊಂದಿದ್ದರೆ, ನೀವು ಮೇಲೆ ಇರಿಸಬಹುದು.

324
00:17:51,490 --> 00:17:56,170
ಇದು ಸಾಕಷ್ಟು ಸಾಮಾನ್ಯವಾಗಿ ಒಳ್ಳೆಯದು
ನೀವು ಬಳಸಿದಾಗ ಏಕೆಂದರೆ ನೆನಪಿಡುವ

325
00:17:56,170 --> 00:17:59,060
ನೀವು ಬಯಸಬಹುದು
ನೆನಪಿಸಿಕೊಂಡು ಹೊಂದಿರುತ್ತದೆ.

326
00:17:59,060 --> 00:18:02,750
ನಿಮ್ಮ ಜೀವನದ ಬಹಳಷ್ಟು ಸುಲಭವಾಗುತ್ತದೆ ಮಾಡುತ್ತೇವೆ.

327
00:18:02,750 --> 00:18:04,000
ನಾನು ನಿಮ್ಮ ಪ್ರಶ್ನೆಗೆ ಡಿಡ್?

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> ಈಗ, ನಾವು ಸ್ವಲ್ಪ ಮಾತಾಡಿಕೊಂಡರು
ಗ್ರಂಥಾಲಯಗಳು ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ.

330
00:18:14,290 --> 00:18:18,570
ಆದರೆ ಎರಡು ಮುಖ್ಯ ಬಿಡಿಗಳ ನಾವು ನಿಜಕ್ಕೂ
ಇಲ್ಲಿಯವರೆಗೆ ಸಂದರ್ಭದಲ್ಲಿ ಬಳಸಿ

331
00:18:18,570 --> 00:18:20,860
ಸ್ಟ್ಯಾಂಡರ್ಡ್ I / O ಮತ್ತು CS50.

332
00:18:20,860 --> 00:18:25,410
ವಿಷಯಗಳನ್ನು ಯಾವ ರೀತಿಯ ಸೇರಿಸಲಾಗಿದೆ
ಸ್ಟ್ಯಾಂಡರ್ಡ್ I / O lib ರಲ್ಲಿ?

333
00:18:25,410 --> 00:18:28,410
>> ಹೌದು, ಇಲ್ಲಿಯವರೆಗೆ ನಾವು printf ಬಳಸಲಾಗುತ್ತದೆ ಬಂದಿದೆ.

334
00:18:28,410 --> 00:18:31,150
CS50 ರಲ್ಲಿ, ನಾವು GetInt ಬಳಸಲಾಗುತ್ತದೆ ಬಂದಿದೆ
ಮತ್ತು GetString.

335
00:18:31,150 --> 00:18:37,200
ಮತ್ತು ಅಕ್ಷಾಂಶ ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ಸಂಭವಿಸುತ್ತದೆ
ಈ CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಘೋಷಣೆ ಮಾಡಲು.

336
00:18:37,200 --> 00:18:40,250
ನಾವು ಬಗ್ಗೆ ಆಳ ಹೆಚ್ಚು ಮಾತನಾಡಲು ವಿಲ್
ಹೇಗೆ ಗ್ರಂಥಾಲಯಗಳು ಕೆಲಸ ಮತ್ತು ಹೇಗೆ

337
00:18:40,250 --> 00:18:41,870
ನಿಮ್ಮ ಕೋಡ್ ಉಳಿದ ಸಂವಹನ.

338
00:18:41,870 --> 00:18:46,220
ಆದರೆ ಆ ಎರಡು ಪ್ರಮುಖ ಇವನ್ನು ನಾವು
ಇಲ್ಲಿಯವರೆಗೆ ರಲ್ಲಿ ಸಂಪರ್ಕಕ್ಕೆ ಬಂದು

339
00:18:46,220 --> 00:18:48,430
ಕೋರ್ಸ್.

340
00:18:48,430 --> 00:18:50,050
>> ವಿಧಗಳು.

341
00:18:50,050 --> 00:18:58,120
ಈ ಎಷ್ಟು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಒಳ್ಳೆಯದು
ಪ್ರತಿಯೊಂದು ಹೇಗೆ ಅಥವಾ ನಿರೂಪಿಸಲಾಗಿದೆ ಇದೆ

342
00:18:58,120 --> 00:19:02,840
ಅನೇಕ ಬೈಟ್ಗಳು ರೀತಿಯ ಪ್ರತಿಯೊಂದು requires--

343
00:19:02,840 --> 00:19:04,990
ಇಂಟ್ 4 ಬೈಟ್ಗಳು; ಚಾರ್, 1 ಬೈಟ್.

344
00:19:04,990 --> 00:19:06,550
ಫ್ಲೋಟ್ 4 ಬೈಟ್ಗಳು.

345
00:19:06,550 --> 00:19:07,782
ಎರಡು ಏನು?

346
00:19:07,782 --> 00:19:09,032
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಆದ್ದರಿಂದ ಒಂದು ಫ್ಲೋಟ್
ಆದರೆ ಗಾತ್ರ ಡಬಲ್.

349
00:19:16,240 --> 00:19:17,150
ಏನು ಬಹಳ ಬಗ್ಗೆ?

350
00:19:17,150 --> 00:19:18,400
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> ಸ್ಪೀಕರ್ 1: ಸರಿ.

353
00:19:24,680 --> 00:19:25,410
ದೀರ್ಘ ಏನು?

354
00:19:25,410 --> 00:19:26,660
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಒಂದು ಇಂಟ್ ಡಬಲ್.

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
ಹೌದು.

359
00:19:34,705 --> 00:19:36,100
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

360
00:19:36,100 --> 00:19:38,030
>> ಸ್ಪೀಕರ್ 1: ಲಾಂಗ್ [ಕೇಳಿಸುವುದಿಲ್ಲ].

361
00:19:38,030 --> 00:19:41,860
ಮತ್ತು ನಂತರ ಒಂದು ದೀರ್ಘ ದೀರ್ಘ ದ್ವಿಗುಣವಾಗಿದೆ.

362
00:19:41,860 --> 00:19:42,814
>> ಪ್ರೇಕ್ಷಕರು: ಇಲ್ಲ, ಇಲ್ಲ.

363
00:19:42,814 --> 00:19:47,107
ಸುದೀರ್ಘ ಕೇವಲ ಒಂದು ಇಂಟ್.

364
00:19:47,107 --> 00:19:50,910
ಇದು ವಿನ್ಯಾಸದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ
ಮೊದಲು [ಕೇಳಿಸುವುದಿಲ್ಲ]

365
00:19:50,910 --> 00:19:52,922
ಮತ್ತು ಇಂಟ್ ಒಂದೇ ಗಾತ್ರ ಹೊಂದಿವೆ.

366
00:19:52,922 --> 00:19:54,172
[ಕೇಳಿಸುವುದಿಲ್ಲ].

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> ಸ್ಪೀಕರ್ 1: ದೀರ್ಘ ಮತ್ತು
ಒಂದು ಇಂಟ್ ಒಂದೇ.

369
00:20:00,920 --> 00:20:02,943
ಮತ್ತು ನಂತರ ಒಂದು ದೀರ್ಘ ದೀರ್ಘ
ಎರಡು ಇಂಟ್.

370
00:20:02,943 --> 00:20:03,910
ಕೂಲ್.

371
00:20:03,910 --> 00:20:05,550
ನಂತರ, ಕಳೆದ ಪ್ರಕಾರ ಏನು?

372
00:20:05,550 --> 00:20:06,510
>> ಪ್ರೇಕ್ಷಕರು: ಪಾಯಿಂಟರ್.

373
00:20:06,510 --> 00:20:10,350
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಆದ್ದರಿಂದ ನಾವು ಕಲಿತ
ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ.

374
00:20:10,350 --> 00:20:14,015
ಮತ್ತು ಲೆಕ್ಕಿಸದೆ ಸೂಚಿಯಾಗಿದೆ ಏನು
ಇದು to-- ತೋರಿಸುವ ಚಾರ್ ಸ್ಟಾರ್ ಆಗಿರಬಹುದು

375
00:20:14,015 --> 00:20:15,880
ಅಥವಾ ಒಂದು ಇಂಟ್ star--

376
00:20:15,880 --> 00:20:20,530
ಇದು ಯಾವಾಗಲೂ ಒಂದು ಪಾಯಿಂಟರ್ 4 ಬೈಟ್ಗಳು ಇಲ್ಲಿದೆ.

377
00:20:20,530 --> 00:20:21,633
ಆ ಬಗ್ಗೆ ಪ್ರಶ್ನೆಗಳು?

378
00:20:21,633 --> 00:20:22,116
ಹೌದು?

379
00:20:22,116 --> 00:20:24,531
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

380
00:20:24,531 --> 00:20:29,530
>> ಸ್ಪೀಕರ್ 1: ದೀರ್ಘ ಮತ್ತು ಒಂದು ಇಂಟ್ ಇವೆ
ಈ CS50 ಉಪಕರಣಗಳಲ್ಲಿರುವ ಅದೇ.

381
00:20:29,530 --> 00:20:32,302
>> ಪ್ರೇಕ್ಷಕರು: ಉಪಕರಣಗಳಲ್ಲಿರುವ ಸಂಪೂರ್ಣವಾಗಿ
ಪರಸ್ಪರ.

382
00:20:32,302 --> 00:20:33,510
>> ಸ್ಪೀಕರ್ 1: ಹೌದು.

383
00:20:33,510 --> 00:20:36,610
ಆದ್ದರಿಂದ ಬಹಳ ಸುದೀರ್ಘ ಎರಡು ಒಂದು ಇಂಟ್ ಹೊಂದಿದೆ.

384
00:20:36,610 --> 00:20:39,250
>> ಪ್ರೇಕ್ಷಕರು: ಈ 32 ಬಿಟ್?

385
00:20:39,250 --> 00:20:40,620
>> ಸ್ಪೀಕರ್ 1: 32 ಬಿಟ್, ಹೌದು.

386
00:20:40,620 --> 00:20:43,572
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

387
00:20:43,572 --> 00:20:46,790
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಇದು ಇದ್ದರೆ
ಸ್ಪಷ್ಟವಾಗಿ, ನೀವು ಹೇಳಲು

388
00:20:46,790 --> 00:20:47,870
ಒಂದು 32 ಬಿಟ್ ಭಾವಿಸುತ್ತಾರೆ ಮಾಡಬೇಕು.

389
00:20:47,870 --> 00:20:50,040
>> ಪ್ರೇಕ್ಷಕರು: ಇದು ಏನಾದರೂ ಹೇಳಬಹುದು
ಒಂದು ಊಹಿಸಿಕೊಂಡು ಹಾಗೆ

390
00:20:50,040 --> 00:20:51,498
ಯಂತ್ರ ವಾಸ್ತುಶಿಲ್ಪ.

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
64 ಬಿಟ್, ಕೇವಲ ವಿಷಯಗಳನ್ನು ಆ
ಬದಲಾವಣೆ ದೂರವುಳಿಯಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ಇವೆ.

393
00:21:01,710 --> 00:21:05,614
ಇಬ್ಬರೂ [ಕೇಳಿಸುವುದಿಲ್ಲ].

394
00:21:05,614 --> 00:21:06,590
>> ಸ್ಪೀಕರ್ 1: ಹೌದು?

395
00:21:06,590 --> 00:21:07,566
>> ಪ್ರೇಕ್ಷಕರು: ಪ್ರಶ್ನೆ.

396
00:21:07,566 --> 00:21:10,982
ಅಭ್ಯಾಸ ರಸಪ್ರಶ್ನೆಗಳು ಮೇಲೆ ಆದ್ದರಿಂದ,
ಒಂದು ರುಜುಮಾಡದ ಇಂಟ್ ಬಗ್ಗೆ ಕೇಳುತ್ತಾನೆ.

397
00:21:10,982 --> 00:21:15,374
ಆದ್ದರಿಂದ ಆ ನಿರ್ಧರಿಸಬಹುದು
ಒಂದು ಇಂಟ್ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

398
00:21:15,374 --> 00:21:18,140
>> ಸ್ಪೀಕರ್ 1: ಸಹಿ
ಸಹ 4 ಬೈಟ್ಗಳು.

399
00:21:18,140 --> 00:21:21,172
ಆದರೆ ಒಂದು ಸಹಿ ಬಗ್ಗೆ ಬೇರೆ ಏನು
ಇಂಟ್ ಮತ್ತು ಸಹಿ ಇಂಟ್?

400
00:21:21,172 --> 00:21:22,422
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> ಸ್ಪೀಕರ್ 1: ರೈಟ್.

403
00:21:25,630 --> 00:21:27,570
ಒಂದು ಋಣಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು.

404
00:21:27,570 --> 00:21:28,580
ಆದರೆ ಅದನ್ನು ಹೇಗೆ ಮಾಡುತ್ತದೆ?

405
00:21:28,580 --> 00:21:30,536
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

406
00:21:30,536 --> 00:21:36,370
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಇದು 1 ಉಳಿಸಿ
ಬಿಟ್ ಸೈನ್ ಪ್ರತಿನಿಧಿಸಲು.

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
ಸಹಿ ಒಂದು ಬಿಟ್ ಹೊಂದಿದೆ
ಸೈನ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

409
00:21:45,040 --> 00:21:48,886
ಮತ್ತು ಸಹಿ ಕೇವಲ ಎಲ್ಲಾ ಧನಾತ್ಮಕ ಹೊಂದಿದೆ.

410
00:21:48,886 --> 00:21:50,365
>> ಪ್ರೇಕ್ಷಕರು: ಸರಿ.

411
00:21:50,365 --> 00:21:54,230
ನೀವು ಎರಡು ಎಂದು ಹೇಳಲು
ಒಂದು ಫ್ಲೋಟ್ ಎರಡು ಬಾರಿ ಗಾತ್ರವನ್ನು?

412
00:21:54,230 --> 00:21:58,202
>> ಸ್ಪೀಕರ್ 1: ಎರಡು ಬಾರಿ ಆಗಿದೆ
ಒಂದು ಫ್ಲೋಟ್ ಗಾತ್ರ, ಹೌದು.

413
00:21:58,202 --> 00:22:01,639
>> ಪ್ರೇಕ್ಷಕರು: ಒಂದು ಪಾಯಿಂಟರ್ ಮಾಡುತ್ತದೆ ಹೇಗೆ
ಒಂದು ದೀರ್ಘ ದೀರ್ಘ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> ಸ್ಪೀಕರ್ 1: ಹೇಗೆ ಆದ್ದರಿಂದ ಪ್ರಶ್ನೆ
ದೀರ್ಘ long-- ಸೂಚಕವನ್ನು

416
00:22:10,870 --> 00:22:13,800
ಹೇಗೆ ಮಾತ್ರ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಆಗಿದೆ
ತನ್ನ 8 ಬೈಟ್ಗಳು ಬಹಳ ಉದ್ದವಾಗಿದೆ.

417
00:22:13,800 --> 00:22:17,310
ಆದ್ದರಿಂದ ಒಂದು ಸೂಚಿಯಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ,
ಮೂಲಭೂತವಾಗಿ, ಬೇಸ್ ಮೌಲ್ಯದಲ್ಲಿ.

418
00:22:17,310 --> 00:22:19,046
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

419
00:22:19,046 --> 00:22:22,670
>> ಸ್ಪೀಕರ್ 1: ಹೌದು, ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್
ಕೇವಲ ಒಂದು ಮೆಮೊರಿ ಹೊಂದಿದೆ.

420
00:22:22,670 --> 00:22:28,040
ಆದ್ದರಿಂದ ಎಷ್ಟು ಜಾಗವನ್ನು ವಿಷಯವಲ್ಲ
ಆ ಪಾಯಿಂಟರ್ ತೋರುತ್ತಿರುವಂತೆ.

421
00:22:28,040 --> 00:22:32,060
ಇದು ಕೇವಲ ಕಾಪಾಡುವುದು 4 ಬೈಟ್ಗಳು ಅಗತ್ಯವಿದೆ
ಮೆಮೊರಿ ಸ್ಥಳ ಆಫ್.

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
ಕೂಲ್.

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> ಆದ್ದರಿಂದ ಕಡೆಯದಾಗಿ ನಾನು
ಗುಣಮಟ್ಟದ ಉತ್ಪಾದನೆ ಆಗಿದೆ.

428
00:22:47,460 --> 00:22:51,020
ನೀವು ಆಗಾಗ ಅವುಗಳನ್ನು ಬಳಸಬೇಕು
ನೀವು ಮರೆಯದಿರಿ ಎಂದು ಸಾಕಷ್ಟು.

429
00:22:51,020 --> 00:22:54,800
ನಾವು ಬಳಸಿದಾಗ ಈ
printf, ಉದಾಹರಣೆಗೆ.

430
00:22:54,800 --> 00:22:59,260
ಮತ್ತು ನಾವು ಈ placeholders ಎಂದು
ಸ್ವರೂಪ ಸಂಕೇತಗಳು ಕರೆಸಲಾಯಿತು.

431
00:22:59,260 --> 00:23:03,910
>> ಆದ್ದರಿಂದ ಇಂಟ್ ರಷ್ಟು ಸಿ ಚಾರ್, ಶೇಕಡಾ ನಾನು,
ಮತ್ತು ನಾವು ಶೇಕಡಾ ಡಿ ಬಳಸಬಹುದು.

432
00:23:03,910 --> 00:23:05,130
ಅದೇ ವಿಷಯ.

433
00:23:05,130 --> 00:23:08,200
ಆದರೆ, ಸಾಮಾನ್ಯವಾಗಿ, ಇನ್, CS50 ನಾವು
ಶೇಕಡಾ ನಾನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿ.

434
00:23:08,200 --> 00:23:09,860
ಫ್ಲೋಟ್ ಶೇಕಡಾ ಎಫ್.

435
00:23:09,860 --> 00:23:15,620
ದೀರ್ಘ ಕಾಲ ಪರ್ಸೆಂಟ್ LD ಮತ್ತು
ತಂತಿಗೆ ರಷ್ಟು ರು.

436
00:23:15,620 --> 00:23:18,550
>> ಹಾಗೆಯೇ, ನಾವು ಕೆಲವು ಬಳಸಿಕೊಂಡು ಬಂದಿದೆ
ಈ ಪಾರು ಅನುಕ್ರಮಗಳನ್ನು.

437
00:23:18,550 --> 00:23:22,431
ಉದಾಹರಣೆಗೆ, ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎನ್ ಹೊಸ ಸಾಲು.

438
00:23:22,431 --> 00:23:26,910
ನೀವು ಫಾರ್ಮಾಟ್ ಮಾಡಿದಾಗ ಕೇವಲ ಹೊಂದಿದೆ
ಮುದ್ರಣ F ನಿಮ್ಮ ಕೋಡ್.

439
00:23:26,910 --> 00:23:27,260
ಹೌದು?

440
00:23:27,260 --> 00:23:28,906
>> ಪ್ರೇಕ್ಷಕರು: ಶೇಕಡಾ ಡಿ ಏನು?

441
00:23:28,906 --> 00:23:31,850
>> ಸ್ಪೀಕರ್ 1: ಪ್ರಶ್ನೆ
ಶೇಕಡಾ ಡಿ ಏನು ಇದೆ?

442
00:23:31,850 --> 00:23:33,270
ಶೇಕಡಾ ಡಿ, ints ಆಗಿದೆ.

443
00:23:33,270 --> 00:23:37,392
ಶೇಕಡಾ ಡಿ ಮತ್ತು ಶೇಕಡಾ ನಾನು ಒಂದೇ.

444
00:23:37,392 --> 00:23:41,130
>> ಪ್ರೇಕ್ಷಕರು: ನಡುವಿನ ಭಿನ್ನತೆ ಏನು
ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎನ್ ಮತ್ತು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಆರ್?

445
00:23:41,130 --> 00:23:45,300
>> ಸ್ಪೀಕರ್ 1: ಪ್ರಶ್ನೆ ಏನು
ಪ್ರತಿಕ್ರಿಯೆ n ಮತ್ತು ನಡುವೆ ವ್ಯತ್ಯಾಸ

446
00:23:45,300 --> 00:23:48,615
ಪ್ರತಿಕ್ರಿಯೆ ಆರ್?

447
00:23:48,615 --> 00:23:50,906
ನಾನು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಆರ್ ಭಾವಿಸುತ್ತೇನೆ ಆಗಿದೆ

448
00:23:50,906 --> 00:23:54,340
>> ಪ್ರೇಕ್ಷಕರು: ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಆರ್ ಕೇವಲ ಸೂಚಿಸುತ್ತದೆ
ಸಾಲಿನ ಆರಂಭಕ್ಕೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ

449
00:23:54,340 --> 00:23:56,670
ವಾಸ್ತವವಾಗಿ ಹೊಸ ಸಾಲಿಗೆ ಹೋಗದೆ.

450
00:23:56,670 --> 00:24:01,000
ಆದ್ದರಿಂದ ನೀವು ಒಂದು backslash ಆರ್ ಮುದ್ರಿಸಿ ನೀವು
ಸಾಲಿನ ಆರಂಭಕ್ಕೆ ಹಿಂದಿರುಗಿ

451
00:24:01,000 --> 00:24:04,005
ನಂತರ ನೀವು ಬದಲಿಸಿ, ಹೆಚ್ಚು ವಿಷಯವನ್ನು ಮುದ್ರಿಸಲು
ಈಗಾಗಲೇ ಇರುವ ವಿಷಯವನ್ನು

452
00:24:04,005 --> 00:24:04,390
[ಕೇಳಿಸುವುದಿಲ್ಲ].

453
00:24:04,390 --> 00:24:06,725
ಆದರೆ, ಎನ್ ವಾಸ್ತವವಾಗಿ ಹೊಸ ಹೋಗುತ್ತದೆ
ಲೈನ್ ಮತ್ತು [ಕೇಳಿಸುವುದಿಲ್ಲ] ಹೋಗುತ್ತದೆ.

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> ಸ್ಪೀಕರ್ 1: ಅಲ್ಲದೆ, ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

456
00:24:13,915 --> 00:24:15,430
ಸರಿ.

457
00:24:15,430 --> 00:24:18,617
ನಾನು ಅದನ್ನು ಆಫ್ ಹ್ಯಾಂಡ್ ಪಡೆಯಲಿದ್ದೇನೆ
ಮುಂದುವರಿಯುತ್ತದೆ ಡಾನ್.

458
00:24:18,617 --> 00:24:25,078
>> [ಚಪ್ಪಾಳೆಯನ್ನು]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> ಡಾನ್: ಎಲ್ಲಾ righty.

461
00:25:09,720 --> 00:25:18,590
ಆದ್ದರಿಂದ ನಾನು ಮತ್ತೊಂದು ವಿಶಾಲ ಬಗ್ಗೆ ಮಾಡುತ್ತೇವೆ
ದರ್ಜೆ ಯೋಜನೆಗಳ ವ್ಯಾಪ್ತಿ

462
00:25:18,590 --> 00:25:23,220
ಸ್ಥೂಲವಾಗಿ ವಾರ ಎರಡು ಪ್ರತಿನಿಧಿ ಮತ್ತು
ವಾರ ಮೂರು ಆರಂಭದಲ್ಲಿ ಪ್ರಾರಂಭ

463
00:25:23,220 --> 00:25:28,690
ಕೇವಲ ಒಂದು ರೀತಿಯಲ್ಲಿ ಇದು ಎರಕದ, ಜೊತೆ
ಕೆಲವು ಪ್ರಕಾರದ ಒಂದು ಮೌಲ್ಯ ಚಿಕಿತ್ಸೆ

464
00:25:28,690 --> 00:25:30,830
ಬೇರೆ ರೀತಿಯ ಒಂದು ಮೌಲ್ಯ.

465
00:25:30,830 --> 00:25:34,110
ನಾವು ಗೆ ಅಕ್ಷರಗಳನ್ನು ಈ ಮಾಡಬಹುದು
ints, ints ಗೆ ತೇಲುತ್ತದೆ ಮತ್ತು

466
00:25:34,110 --> 00:25:35,360
ದೀರ್ಘ ದೂರವುಳಿಯಬೇಕಾಗುತ್ತದೆ ಡಬಲ್.

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> ಈ ಎಲ್ಲ ವಿಷಯಗಳ ರೀತಿಯಲ್ಲಿ ಬಳಸಬಹುದು
ಕೆಲವು ಸಂಖ್ಯಾ ಮೌಲ್ಯದ ಚಿಕಿತ್ಸೆ

469
00:25:44,500 --> 00:25:48,370
ಕೆಲವು ಮಾಹಿತಿ ಮೈನಸ್ ಚಾರ್
ಸಂಖ್ಯಾ ಮೌಲ್ಯ.

470
00:25:48,370 --> 00:25:54,480
ಕೆಲವು ವಿಷಯಗಳು ಈ, ನ ಜೊತೆ ಇವೆ ಹಾಗಾಗಿ
ನೀವು ಪಾತ್ರ ಬರುತ್ತದೆ ಕೋರ್ಸ್,

471
00:25:54,480 --> 00:25:57,860
ints ಗೆ ಫ್ಲೋಟ್ ವಿಷಯಗಳನ್ನು.

472
00:25:57,860 --> 00:26:00,500
ಆದ್ದರಿಂದ ಈ ಸ್ವಲ್ಪ ವಿಲಕ್ಷಣ.

473
00:26:00,500 --> 00:26:03,170
ನಾವು 1.31 ಒಂದು ಫ್ಲೋಟ್.

474
00:26:03,170 --> 00:26:05,220
ನಾವು 10,000 ಅದನ್ನು ಗುಣಿಸಿದಾಗ.

475
00:26:05,220 --> 00:26:08,380
ನಂತರ ನಾವು ಒಂದು ಇಂಟ್ ಅದನ್ನು ಮುದ್ರಿಸಲು.

476
00:26:08,380 --> 00:26:09,630
ಈ ಔಟ್ಪುಟ್ ಏನು?

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10,000 ಬಾರಿ 1.31.

479
00:26:14,020 --> 00:26:18,761
ಆದ್ದರಿಂದ 13,000, ಊಹೆ?

480
00:26:18,761 --> 00:26:20,685
>> ಪ್ರೇಕ್ಷಕರು: ನಾನು 10,000 ಹಿತ.

481
00:26:20,685 --> 00:26:24,234
>> ಡಾನ್: ಹಾಗಾಗಿ 10,000 ರಿಂದ ಗುಣಿಸಿ ಬಾಗುತ್ತೇನೆ
ನಾನು ಎರಕ ನುಡಿದರು ಮೊದಲು.

482
00:26:24,234 --> 00:26:25,202
>> ಪ್ರೇಕ್ಷಕರು: ಓಹ್.

483
00:26:25,202 --> 00:26:27,622
ಅಲ್ಲಿ ಒಂದು 9 ಆಗಲಿಲ್ಲ
ಮತ್ತು ಕೆಲವು 0 ಸಂಖ್ಯೆಗಳನ್ನು?

484
00:26:27,622 --> 00:26:29,270
>> ಡಾನ್: ನೀವು ಕೆಲವು ವಿಲಕ್ಷಣ ಅಂಕೆಗಳು ಹೊಂದಿರಬಹುದು.

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
ಆದ್ದರಿಂದ ಬಲ, ಇದು 1.3 ಬಾರಿ 10,000 ಇಲ್ಲಿದೆ.

487
00:26:37,670 --> 00:26:40,040
ಆದ್ದರಿಂದ 13,000 ಇಲ್ಲಿದೆ.

488
00:26:40,040 --> 00:26:41,313
ಈ ಹೆಚ್ಚುವರಿ weird--

489
00:26:41,313 --> 00:26:42,160
>> ಪ್ರೇಕ್ಷಕರು: 13.100.

490
00:26:42,160 --> 00:26:42,650
>> ಡಾನ್: 13.100.

491
00:26:42,650 --> 00:26:44,910
, ರಾಬ್ ಧನ್ಯವಾದಗಳು.

492
00:26:44,910 --> 00:26:46,610
ಈ ಹೆಚ್ಚುವರಿ weirdness--

493
00:26:46,610 --> 00:26:48,060
ಈ 9,9--

494
00:26:48,060 --> 00:26:53,860
ಕೇವಲ ಈ ಎರಕದ ಕಾರಣ
ಕೊನೆಗೊಂಡಿತು ಕೆಳಗೆ ಅಲ್ಲಿ ಪೂರ್ಣಾಂಕವನ್ನು

495
00:26:53,860 --> 00:26:55,394
ಇದು ಹಾಗಿಲ್ಲ.

496
00:26:55,394 --> 00:26:55,871
ಹೌದು.

497
00:26:55,871 --> 00:26:58,256
>> ಪ್ರೇಕ್ಷಕರು: ಎರಕದ ನಡೆಯುತ್ತದೆ
ಬೇರೆ ಏನು ನಂತರ?

498
00:26:58,256 --> 00:27:03,865
>> ಡಾನ್: ಏಕೆಂದರೆ ನಾನು, ಮುದ್ರಣದಲ್ಲಿ ಹೊಂದಿವೆ
ಇದು ಮೊದಲು ಈ ಗುಣಾಕಾರ ಮಾಡುತ್ತದೆ

499
00:27:03,865 --> 00:27:05,230
ಈ ಎರಕ ಇಲ್ಲ.

500
00:27:05,230 --> 00:27:06,140
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

501
00:27:06,140 --> 00:27:11,350
>> ಡಾನ್: ನಾನು, ಇದು ಮೊದಲ ಪಾತ್ರ ಹೇಳುವೆ
ಹೌದು, 10,000 ಇದು ಎಂದು.

502
00:27:11,350 --> 00:27:12,610
ಬೇರೆ ಏನು?

503
00:27:12,610 --> 00:27:13,330
ಕೂಲ್.

504
00:27:13,330 --> 00:27:16,344
ಆದ್ದರಿಂದ ಈ 13.099 ಹೊಂದಿದೆ.

505
00:27:16,344 --> 00:27:17,840
ಏಕೆ ಹೀಗಾಗುತ್ತದೆ?

506
00:27:17,840 --> 00:27:18,900
ನಿಖರತೆಯ.

507
00:27:18,900 --> 00:27:21,020
>> ಫ್ಲೋಟ್ಗಳು ಪರಿಪೂರ್ಣ ಅಲ್ಲ.

508
00:27:21,020 --> 00:27:27,550
ಅವರು ಕೇವಲ ಒಂದು ಗೆ ಸಂಖ್ಯೆಯನ್ನೂ ಪ್ರತಿನಿಧಿಸುವ
ಗಮನಾರ್ಹ ವ್ಯಕ್ತಿಗಳು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ.

509
00:27:27,550 --> 00:27:35,120
ನಾವು 8 ಸರಿಪಡಿಸು ಅಂಜೂರದ ಮುದ್ರಿಸುತ್ತದೆ ಆದ್ದರಿಂದ
ಈ ಫ್ಲೋಟ್, ನಾವು ಒಂದು ರೀತಿಯ ಪಡೆಯಲು

510
00:27:35,120 --> 00:27:36,800
ಕೊಳಕು ಕಾಣುವ ಸಂಖ್ಯೆ.

511
00:27:36,800 --> 00:27:45,580
ಮತ್ತು ಹೀಗಾಗಲು ಕಾರಣ 1.31 ನಿಖರವಾಗಿ ಸಾಧ್ಯವಿಲ್ಲ
ಸರಳ ನಿರೂಪಣೆಯಿಂದ

512
00:27:45,580 --> 00:27:49,000
ಯಂತ್ರದಲ್ಲಿ ಎರಡು ಶಕ್ತಿಗಳು.

513
00:27:49,000 --> 00:27:53,530
ಇದು ಹತ್ತಿರದ ತೆಗೆದುಕೊಂಡು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಆದ್ದರಿಂದ
ಇದು ಅಂತ್ಯಗೊಳ್ಳುತ್ತದೆ, ಊಹೆ

514
00:27:53,530 --> 00:27:55,710
ಸ್ವಲ್ಪ ಕಡಿಮೆ ಎಂದು.

515
00:27:55,710 --> 00:27:57,730
ಅರ್ಥ?

516
00:27:57,730 --> 00:27:59,110
ಸರಿ.

517
00:27:59,110 --> 00:28:05,840
>> ಈಗ, ಸ್ವಿಚ್ ಒಂದು ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ಇವೆ
ಷರತ್ತಿನ ಹೇಳಿಕೆಗಳು ಅಲ್ಲಿ ಎಲ್ಲಾ ಮಾಡುವ

518
00:28:05,840 --> 00:28:09,900
ನಾವು ಒಂದು ವೇರಿಯಬಲ್ ಕಾಳಜಿ.

519
00:28:09,900 --> 00:28:16,570
ಆದ್ದರಿಂದ ಈ ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ನೀವು
ಬಳಕೆದಾರ ಒಂದು ಪೂರ್ಣಾಂಕ ಪಡೆಯುವಲ್ಲಿ.

520
00:28:16,570 --> 00:28:21,070
ತದನಂತರ ನಾವು ಹುಡುಕುತ್ತಿರುವುದನ್ನು
ಪೂರ್ಣಾಂಕ ಏನು.

521
00:28:21,070 --> 00:28:23,500
ಬಹುಶಃ ಇದು ಸಂಖ್ಯೆಯ
ಒಂದು ಮತ್ತು ನಾಲ್ಕು.

522
00:28:23,500 --> 00:28:24,800
ನಾವು ಕೇಳುವ ಏನನ್ನು ಇಲ್ಲಿದೆ.

523
00:28:24,800 --> 00:28:28,450
>> ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಸ್ವಿಚ್ ಮಾಡಿ
ವೇರಿಯಬಲ್ ಹೆಸರು.

524
00:28:28,450 --> 00:28:34,290
ನಂತರ ನೀವು ಸಾಧ್ಯವಾದಷ್ಟು ಪ್ರಕರಣಗಳಲ್ಲಿ ಸ್ಥಾಪಿಸಲು
ಇದು ಆಗಿರಬಹುದು ಗೌರವಿಸುತ್ತಾರೆ.

525
00:28:34,290 --> 00:28:37,730
ಆದ್ದರಿಂದ ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಕಡಿಮೆ ಹೇಳುತ್ತಾರೆ.

526
00:28:37,730 --> 00:28:41,080
ತದನಂತರ ನೀವು ಹೊರಬರಲು ಮುರಿಯಲು
ಸ್ವಿಚ್ ಪರಿಸ್ಥಿತಿಯ ಆದ್ದರಿಂದ

527
00:28:41,080 --> 00:28:43,270
ನೀವು ಮುಂದುವರಿಸುವುದಕ್ಕೆ ಇಲ್ಲ.

528
00:28:43,270 --> 00:28:44,830
>> ಮುಂದಿನ ಸಂದರ್ಭದಲ್ಲಿ

529
00:28:44,830 --> 00:28:46,940
ಆದ್ದರಿಂದ ಸಂದರ್ಭದಲ್ಲಿ ಎರಡು ಮತ್ತು ಸಂದರ್ಭದಲ್ಲಿ three--

530
00:28:46,940 --> 00:28:51,920
ಇದು ಸಂದರ್ಭದಲ್ಲಿ ಎರಡು ಇಲ್ಲಿದೆ ಅದು ಇಳಿಯುತ್ತದೆ
ಇದು ಕಾಣುತ್ತದೆ ಕೋಡ್ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ

531
00:28:51,920 --> 00:28:55,400
ಇದು ಒಂದು ಬ್ರೇಕ್ ನೋಡುವ ತನಕ ಮೂರು ಕೇಸ್.

532
00:28:55,400 --> 00:29:00,430
ಆದ್ದರಿಂದ ಕಾರಣ ನಿಮಗೆ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಡೆಯಲು
ಕೇವಲ ಮುದ್ರಣ ಕಡಿಮೆ ನಾನು

533
00:29:00,430 --> 00:29:01,890
ಇಲ್ಲಿ ಈ ವಿರಾಮ.

534
00:29:01,890 --> 00:29:05,360
ನಾನು ಮಾಡಿದಲ್ಲಿ ಈ break-- ಕಡೆಗಣಿಸಲಾಗುತ್ತದೆ
ನಾನು ಈ breakaway-- ಎಸೆದ ವೇಳೆ

535
00:29:05,360 --> 00:29:09,740
ಇದು ಕಡಿಮೆ ಮುದ್ರಿಸಲು ಎಂದು, ಮತ್ತು ನಂತರ ಅದನ್ನು
ಮಧ್ಯಮ ಮುದ್ರಿಸಲು, ಮತ್ತು ನಂತರ ಅದನ್ನು ಮುರಿಯಲು.

536
00:29:09,740 --> 00:29:12,200
>> ಮುರಿದರೆ ಒಂದು ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ ಆದ್ದರಿಂದ
ಷರತ್ತುಗಳು ಬದಲಾಯಿಸಲು ಮತ್ತು

537
00:29:12,200 --> 00:29:14,340
ಅವರು ಇರಬೇಕು.

538
00:29:14,340 --> 00:29:20,070
ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳಿದ್ದಾರೆ ಎಂದು ಯಾವುದೇ ಸಂದರ್ಭಗಳಲ್ಲಿ
ಡೀಫಾಲ್ಟ್ ನಿರ್ವಹಿಸುತ್ತಾರೆ

539
00:29:20,070 --> 00:29:26,645
ಮತ್ತು ಸ್ವಿಚ್ ಸಂದರ್ಭದಲ್ಲಿ ಪಾತ್ರ ಮಾಡಬೇಕು.

540
00:29:26,645 --> 00:29:31,363
>> ಪ್ರೇಕ್ಷಕರು: 1, 2, 3,
ಮತ್ತು 4 ಎನ್ ಎಂದು?

541
00:29:31,363 --> 00:29:33,310
>> ಡಾನ್: ಎನ್ ಎಂದು ಮೌಲ್ಯಗಳು.

542
00:29:33,310 --> 00:29:34,654
ಹೌದು.

543
00:29:34,654 --> 00:29:35,146
ಹೌದು?

544
00:29:35,146 --> 00:29:37,606
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ಹೊಂದಿರುವಾಗ
[ಕೇಳಿಸುವುದಿಲ್ಲ]?

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> ಡಾನ್: ನಂತರ ಕಡಿಮೆ ಮುದ್ರಿಸಲು, ಮತ್ತು ಎಂದು
ಇದು ಮಧ್ಯಮ ಮುದ್ರಿಸಲು, ಮತ್ತು ಎಂದು

547
00:29:46,830 --> 00:29:47,400
ನಂತರ ಅದನ್ನು ಮುರಿಯಲು.

548
00:29:47,400 --> 00:29:50,244
>> ಪ್ರೇಕ್ಷಕರು: ವೈ ಇದು ಮುದ್ರಿಸಲು ಎಂದು
ಮಧ್ಯಮ ವೇಳೆ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> ಡಾನ್: ಪ್ರಕರಣ ಅಡಿಯಲ್ಲಿ ಎಲ್ಲವನ್ನೂ
ವಿರಾಮ ಬೀಳುವ ಮೊದಲು.

551
00:30:00,550 --> 00:30:09,390
ಆದ್ದರಿಂದ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಮುದ್ರಣ ಕೆಳಗೆ ಸಂದರ್ಭ
ಒಂದು ಈ ಕೆಳಗಿನ ಮುದ್ರಿಸು.

552
00:30:09,390 --> 00:30:09,890
ಹೌದು?

553
00:30:09,890 --> 00:30:11,140
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> ಡಾನ್: ಈ ಸಂಖ್ಯೆ ಕೇವಲ ಒಂದು ನಿರ್ದಿಷ್ಟ ಹೊಂದಿದೆ
ಮೌಲ್ಯದ ಈ ವೇರಿಯಬಲ್

556
00:30:22,170 --> 00:30:23,420
ಬಲ, ತೆಗೆದುಕೊಳ್ಳಬಹುದು?

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
ಎಂದು ಅರ್ಥ ಡಸ್?

559
00:30:28,490 --> 00:30:28,990
ಹೌದು.

560
00:30:28,990 --> 00:30:31,490
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

561
00:30:31,490 --> 00:30:34,130
>> ಡಾನ್: ಹೌದು, ಸಂದರ್ಭದಲ್ಲಿ ಎರಡು ಮುದ್ರಿಸಲು ಎಂದು
ಮಧ್ಯಮ ಮತ್ತು ನಂತರ ಮುರಿಯಲು.

562
00:30:34,130 --> 00:30:35,380
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> ಡಾನ್: ನಾನು ಯಾವುದೇ ಭಾವಿಸುತ್ತೇನೆ?

565
00:30:40,050 --> 00:30:43,855
ಇತರ ಡೇಟಾ ಪ್ರಕಾರಗಳು
ನೀವು ಮೇಲೆ ಬದಲಾಯಿಸಬಹುದು?

566
00:30:43,855 --> 00:30:46,320
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ಬದಲಾಯಿಸಬಹುದು
ಯಾವುದೇ ಡೇಟಾವನ್ನು ರೀತಿಯ ಮೇಲೆ.

567
00:30:46,320 --> 00:30:50,905
ಆದರೆ ಇದು ಕೇವಲ ಅಕ್ಷರಗಳನ್ನು ಮೇಲೆ ಏನು ಅರ್ಥ
ಮತ್ತು ints ಮತ್ತು ಹಾಗೆ ಸ್ಟಫ್, ಏಕೆಂದರೆ

568
00:30:50,905 --> 00:30:55,600
ನೀವು ಪಾಯಿಂಟರ್ ಸ್ವಿಚಿಂಗ್ ಬಳಸುತ್ತಿದ್ದರೆ
ನಿಜಕ್ಕೂ, ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ

569
00:30:55,600 --> 00:30:59,555
ಇದು ಅವಕಾಶ ವೇಳೆ, ಲೋಡ್ ಸ್ವಿಚಿಂಗ್
ನೀವು ಏಕೆಂದರೆ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್, ಹಾಗೆ

570
00:30:59,555 --> 00:31:02,840
ನಿಖರ, ನೀವು ನಿಜವಾಗಿಯೂ ಅಲ್ಲ
ಹೇಗಾದರೂ ಹಾಗೆ ಬಯಸುವ.

571
00:31:02,840 --> 00:31:07,320
ಆದ್ದರಿಂದ ಅತ್ಯಧಿಕವಾಗಿ, ಕೇವಲ ints ಮತ್ತು
ಹಾಗೆ ಅಕ್ಷರಗಳನ್ನು ಮತ್ತು ಸ್ಟಫ್.

572
00:31:07,320 --> 00:31:12,360
>> ಡಾನ್: ನೀವು ಸ್ಪಷ್ಟ ಮಾಡಿಕೊಂಡು ಹೌದು, ಇದು
ನಿಮಗೆ ಮೌಲ್ಯಗಳನ್ನು ಎಂದು, ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಮಾಡಬಹುದು

573
00:31:12,360 --> 00:31:14,250
ಒಂದು ಸ್ವಿಚ್ ವಾಸ್ತವವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
ಉತ್ತಮ?

576
00:31:18,990 --> 00:31:21,370
ಸರಿ.

577
00:31:21,370 --> 00:31:26,180
>> ಉದ್ದೇಶ ಒಂದು ವರದಿಯಂತೆ ಶ್ರೇಣಿ
ವೇರಿಯಬಲ್ ವಿಸ್ತರಿಸುತ್ತದೆ.

578
00:31:26,180 --> 00:31:32,190
ನಾನು ಕೋಡ್ ಈ ಕಡಿಮೆ ಪಾಲನ್ನು ಆದ್ದರಿಂದ,
ಇದು ತಪ್ಪುಗಳ ಪೂರ್ಣ ಎಂದು.

579
00:31:32,190 --> 00:31:41,450
ಮತ್ತು ಕಾರಣ ನಾನು ಈ ಇಂಟ್ ಡಿಕ್ಲೇರ್ಡ್
ನಾನು ಲೂಪ್ ಈ ವ್ಯಾಪ್ತಿಯಲ್ಲಿ.

580
00:31:41,450 --> 00:31:46,390
ತದನಂತರ ನಾನು ಉಲ್ಲೇಖಿಸಿ ಪ್ರಯತ್ನಿಸುವಾಗ ನಾನು
ನಾನು ಲೂಪ್ ವ್ಯಾಪ್ತಿ ಹೊರಗೆ.

581
00:31:46,390 --> 00:31:50,330
>> ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ನೀವು ವ್ಯಾಪ್ತಿ ಬಗ್ಗೆ
ನೀವು ಘೋಷಿಸಲು ಎಂದು ಏನು

582
00:31:50,330 --> 00:31:59,750
ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಒಂದು ಸೆಟ್ ಒಳಗೆ ಮಾತ್ರ
ಆ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಒಳಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

583
00:31:59,750 --> 00:32:04,990
ಮತ್ತು ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ವೇರಿಯಬಲ್ ಬಳಸುತ್ತಿದ್ದರೆ
ಆ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಹೊರಗೆ, ನೀವು

584
00:32:04,990 --> 00:32:08,356
ಕಂಪೈಲರ್ ದೋಷ ಪಡೆಯಲು.

585
00:32:08,356 --> 00:32:08,812
ಹೌದು?

586
00:32:08,812 --> 00:32:09,724
>> ಪ್ರೇಕ್ಷಕರು: ಈ ಒಂದು ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ?

587
00:32:09,724 --> 00:32:11,790
>> ಡಾನ್: ಈ ಹೌದು, ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ.

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
ತಂತುಗಳನ್ನು.

590
00:32:18,660 --> 00:32:19,780
ಸರಣಿ ಒಂದು ಚಾರ್ *.

591
00:32:19,780 --> 00:32:22,250
ಅವರು ಒಂದೇ ಆರ್.

592
00:32:22,250 --> 00:32:25,540
ಅವರು ಕೇವಲ ಪಾತ್ರಗಳು ರೀತಿಯು.

593
00:32:25,540 --> 00:32:33,000
ಮತ್ತು ನೀವು ಯಾವುದೇ ತಂತಿಗಳ ಕೊನೆಗೊಳ್ಳಬೇಕು
ಕೇವಲ ಇದು backslash ಶೂನ್ಯ, ಜೊತೆ

594
00:32:33,000 --> 00:32:34,410
ಒಂದು ಸಿ ಸಮಾವೇಶ.

595
00:32:34,410 --> 00:32:36,680
>> ಇದು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಟರ್ಮಿನೇಟರ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

596
00:32:36,680 --> 00:32:39,050
ಮತ್ತು ಶೂನ್ಯ

597
00:32:39,050 --> 00:32:41,670
ಬಂಡವಾಳ ಎನ್, ರಾಜಧಾನಿ ಯು ಬಂಡವಾಳ
ಎಲ್, ಬಂಡವಾಳ L--

598
00:32:41,670 --> 00:32:44,290
ಅದೇ ಅಲ್ಲ
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಟರ್ಮಿನೇಟರ್.

599
00:32:44,290 --> 00:32:46,640
ಈ ಪಾಯಿಂಟರ್.

600
00:32:46,640 --> 00:32:48,280
ಈ ಪಾತ್ರ.

601
00:32:48,280 --> 00:32:49,530
ಅವರು ಬಹಳ ಭಿನ್ನ.

602
00:32:49,530 --> 00:32:50,200
ಇದು ನೆನಪಿಡಿ.

603
00:32:50,200 --> 00:32:52,320
ಬಹುಶಃ, ರಸಪ್ರಶ್ನೆ ಇರುತ್ತದೆ.

604
00:32:52,320 --> 00:32:54,040
ನಾನು ರಸಪ್ರಶ್ನೆ ನೋಡಿಲ್ಲ.

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
ಹೌದು?

607
00:32:58,840 --> 00:33:01,232
>> ಪ್ರೇಕ್ಷಕರು: ನಲ್ ಪಾಯಿಂಟರ್, ಹೇಳುತ್ತಾರೆ, ಆಗಿದೆ?

608
00:33:01,232 --> 00:33:01,995
>> ಡಾನ್: ಹೌದು.

609
00:33:01,995 --> 00:33:05,170
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ] ಮಾಡುತ್ತದೆ?

610
00:33:05,170 --> 00:33:10,050
>> ಡಾನ್:, ಹೇಳಲು ವೇಳೆ, malloc ಎಂದು ಇದ್ದಾಗ
ಪಡೆಯಲು ಸಾಕಷ್ಟು ಮೆಮೊರಿ ಇಲ್ಲ

611
00:33:10,050 --> 00:33:14,400
ಏನೇ ಕೇಳುತ್ತಿದೆ ನೀವು ಗಾತ್ರ,
malloc ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ಕಾಣಿಸುತ್ತದೆ.

612
00:33:14,400 --> 00:33:19,550
ಕ್ರಿಯೆಯಾಗಿದೆ ಬಂದ ಇದು, ಮೂಲತಃ, ಇಲ್ಲಿದೆ
ಒಂದು ಪಾಯಿಂಟರ್ ಮರಳಲು ಮಾಡಬೇಕೋ, ನೀವು

613
00:33:19,550 --> 00:33:22,600
ಶೂನ್ಯ ಏಕೆಂದರೆ ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಬೇಕು
ಶೂನ್ಯ ಬಹಳ good-- ಆಗಿದೆ

614
00:33:22,600 --> 00:33:25,260
ಇದು ರೀತಿಯ, ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯವೇನು.

615
00:33:25,260 --> 00:33:27,050
ಇದು ದೂರದ ಪಾಯಿಂಟರ್ಸ್ ಹೋಗಿ ಎಂದು ಶೂನ್ಯ ಇಲ್ಲಿದೆ.

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> ಯಾವಾಗ ನೀವು ಒಂದು ಕಾರ್ಯ ಕರೆ,
ಒಂದು ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

618
00:33:32,250 --> 00:33:35,960
ನೀವು ಎಂದು ಪರಿಶೀಲಿಸಲು ಬಯಸುವ ಎಂದು ನೀನು
ಪಾಯಿಂಟರ್ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಎಂದು ಖಚಿತವಾಗಿ

619
00:33:35,960 --> 00:33:37,760
ಶೂನ್ಯ ಬಹಳ ಸಾಮಾನ್ಯ ಏಕೆಂದರೆ.

620
00:33:37,760 --> 00:33:40,160
ಇದು ಒಂದು ಕಸದ ರಿಟರ್ನ್ ರೀತಿಯ ಇಲ್ಲಿದೆ.

621
00:33:40,160 --> 00:33:44,902
ಏನೊ ಹೋಗಲಿಲ್ಲ ಆದ್ದರಿಂದ,
ಕೇವಲ ಬದಲಿಗೆ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ.

622
00:33:44,902 --> 00:33:45,898
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

623
00:33:45,898 --> 00:33:48,922
>> ಡಾನ್: ಹೌದು, ಮತ್ತು ಈ ಇಲ್ಲಿದೆ.

624
00:33:48,922 --> 00:33:51,750
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

625
00:33:51,750 --> 00:33:52,800
>> ಡಾನ್: ಈ ಎಂದು ಕಾಗುಣಿತ.

626
00:33:52,800 --> 00:33:54,150
ಇದು ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಟರ್ಮಿನೇಟರ್ ಇಲ್ಲಿದೆ.

627
00:33:54,150 --> 00:33:56,560
ಇದು ಎನ್ ಯು ಎಲ್ ಎಲ್ ವೇಳೆ ಇಲ್ಲಿದೆ
ನೀವು ಕಾಗುಣಿತ ಬಳಸುತ್ತಿದ್ದರೆ.

628
00:33:56,560 --> 00:33:59,860
>> ಪ್ರೇಕ್ಷಕರು: ನಾನು ಹೋದರು
ಹಿಂದೆ ಇದನ್ನು ಪರೀಕ್ಷಿಸಲಾಯಿತು.

629
00:33:59,860 --> 00:34:03,010
ಮತ್ತು ನೀವು ಒಂದು ತೇಲುವ ಬಿಂದು ಹಾಕಲು ಪ್ರಯತ್ನಿಸಿದರೆ
ಒಂದು ಸ್ವಿಚ್ ಮೌಲ್ಯವನ್ನು, ನೀವು ಕೋಪ ಬರುತ್ತದೆ

630
00:34:03,010 --> 00:34:05,916
ಹೇಳುವ ಹೇಳಿಕೆ ಅಭಿವ್ಯಕ್ತಿ ಅಗತ್ಯವಿದೆ
ಪೂರ್ಣಾಂಕ ರೀತಿಯ.

631
00:34:05,916 --> 00:34:07,166
>> ಡಾನ್: ಅಲ್ಲಿ ನೀವು ಹೋಗಿ.

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
ಆದರೆ ಹೌದು, ಪ್ರಶ್ನೆ ಮತ್ತೆ ಏನು?

634
00:34:12,246 --> 00:34:13,496
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> ಡಾನ್: ಆದ್ದರಿಂದ ಬಂಡವಾಳ ಎನ್, ರಾಜಧಾನಿ ಯು ಬಂಡವಾಳ
ಎಲ್, ಬಂಡವಾಳ ಎಲ್ ನಿಜವಾದ ಸಿ ವಿಷಯ.

637
00:34:23,679 --> 00:34:29,719
ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಮತ್ತು ತಿನ್ನುವೆ
ಮಾತ್ರ ಪರಿಗಣಿಸಬೇಕು.

638
00:34:29,719 --> 00:34:33,530
ನೀವು ಎಂದಾದರೂ ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಕಾಗುಣಿತ ಸಾಧ್ಯವಿಲ್ಲ
ಶೂನ್ಯಚಿಹ್ನೆ ಮತ್ತು ಯಾವುದೇ ನೋಡಿ

639
00:34:33,530 --> 00:34:35,630
ಈ ಬೇರೆ ರೀತಿಯಲ್ಲಿ.

640
00:34:35,630 --> 00:34:36,610
ಹೌದು?

641
00:34:36,610 --> 00:34:42,490
>> ಪ್ರೇಕ್ಷಕರು: ಗರಿಷ್ಠ ಚಾರ್ ಹಿಂದಿರುಗಿದ ಅಥವಾ
ಟಿಪ್ಪಣಿಗಳು ಏನೋ, ಅದನ್ನು

642
00:34:42,490 --> 00:34:43,960
ಅದೇ ಕಾರ್ಯ ಸಾಕಾರಗೊಳಿಸಿದರು
[ಕೇಳಿಸುವುದಿಲ್ಲ] ಎಂದು?

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ಉಲ್ಲೇಖಿಸುವಾಗ
GetChar ರಿಂದ ಚಾರ್ ಗರಿಷ್ಠ ಹಿಂದಿರುಗಿದ, ಅಥವಾ

645
00:34:54,949 --> 00:34:55,444
ಏನೇ ಅದು?

646
00:34:55,444 --> 00:34:55,940
>> ಪ್ರೇಕ್ಷಕರು: ಹೌದು.

647
00:34:55,940 --> 00:34:58,620
>> ಪ್ರೇಕ್ಷಕರು: ಹೌದು, ಸಾಮಾನ್ಯ ಆದ್ದರಿಂದ
ಎಲ್ಲಾ ವಿಷಯಗಳನ್ನು ಪದ

648
00:34:58,620 --> 00:34:59,920
ಸೆಂಟಿನೆಲ್ ಮೌಲ್ಯಗಳು.

649
00:34:59,920 --> 00:35:03,640
ಆದ್ದರಿಂದ GetInt ಇಂಟ್ ಗರಿಷ್ಠ ಹಿಂದಿರುಗಿದ
ಮತ್ತು GetChar ರಿಂದ ಚಾರ್ ಗರಿಷ್ಠ, ಅಷ್ಟೇ

650
00:35:03,640 --> 00:35:06,010
ವೇಳೆ, ಸರಿ, ಹಾಗೆ ಆಗಿರಬೇಕು
ಈ ವಿಷಯಗಳನ್ನು ನಮಗೆ ಹಿಂದಿರುಗುತ್ತಿದ್ದಾರೆ

651
00:35:06,010 --> 00:35:07,210
ಏನೋ ತಪ್ಪಾಗಿದೆ.

652
00:35:07,210 --> 00:35:09,950
>> ಪಾಯಿಂಟರ್ಸ್, ನಾವು ಕೇವಲ ಹೊಂದಿರುತ್ತವೆ ಸಂಭವಿಸಬಹುದು
ಈ ಸೆಂಟಿನೆಲ್ ಮೌಲ್ಯ ಪ್ರತಿಯೊಬ್ಬರೂ

653
00:35:09,950 --> 00:35:10,750
ಪರಸ್ಪರ ಸಮ್ಮತಿಯಿಂದ.

654
00:35:10,750 --> 00:35:13,210
ಮತ್ತು ಈ ನೀವು ಮರಳಿ ವಿಷಯ
ವಿಷಯಗಳನ್ನು ತಪ್ಪು ಹೋಗಿ.

655
00:35:13,210 --> 00:35:15,910
ಆದ್ದರಿಂದ ಚಾರ್ ಗರಿಷ್ಠ ನಾವು ಬಳಸುತ್ತಿರುವ ಏನು
ಏನೋ ಪ್ರತಿನಿಧಿಸಲು

656
00:35:15,910 --> 00:35:18,100
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಅಥವಾ GetChar ಹಾಗೆ.

657
00:35:18,100 --> 00:35:23,420
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು GetChar ಪರೀಕ್ಷಿಸುತ್ತಿದ್ದೇವೆ ಹಾಗಿದ್ದಲ್ಲಿ
ನೀವು ಶೂನ್ಯ ಹಾಕಲು ಸಾಧ್ಯವಾಯಿತು?

658
00:35:23,420 --> 00:35:23,910
ಒಂದು ವ್ಯತ್ಯಾಸ ಮಾಡಲು ಬಯಸುವಿರಾ?

659
00:35:23,910 --> 00:35:25,400
>> ಡಾನ್: ನೀವು ಶೂನ್ಯ ಪರಿಶೀಲಿಸಿ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

660
00:35:25,400 --> 00:35:30,130
ನೀವು ಏಕೆಂದರೆ ಚಾರ್ ಗರಿಷ್ಠ ಪರೀಕ್ಷಿಸಲು ಮಾಡಿದೆವು
ಕಾರ್ಯ ಹಿಂತಿರುಗುವ ಕೆಳಗಿನ

661
00:35:30,130 --> 00:35:35,416
ಒಂದು ಪಾತ್ರದ ಒಂದು ಪಾಯಿಂಟರ್ ಅಲ್ಲ.

662
00:35:35,416 --> 00:35:35,888
ಹೌದು?

663
00:35:35,888 --> 00:35:38,248
>> ಪ್ರೇಕ್ಷಕರು: ಈ ಪ್ರಶ್ನೆ ಕೇಳುತ್ತಾನೆ
ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ.

664
00:35:38,248 --> 00:35:40,136
ಶೂನ್ಯಚಿಹ್ನೆ ಹೊಂದಿರುವ ಡಸ್?

665
00:35:40,136 --> 00:35:41,000
>> ಡಾನ್: ನಂ

666
00:35:41,000 --> 00:35:45,930
ಮತ್ತು ಹೇಗೆ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ವಾಸ್ತವವಾಗಿ
ಇದು ಸಾಗುವ ಕಾರಣ ನಿಲ್ಲಿಸಲು ತಿಳಿದಿದೆ

667
00:35:45,930 --> 00:35:49,070
ಪಾತ್ರಗಳ ನಿಮ್ಮ ರಚನೆಯ ರವರೆಗೆ
ಇದು ಒಂದು ಶೂನ್ಯಚಿಹ್ನೆ ನೋಡುತ್ತಾನೆ.

668
00:35:49,070 --> 00:35:51,030
ನಂತರ ಇದು ಎಲ್ಲಾ, ಹೀಗಿದೆ
ಸರಿ, ನಾನು ಮುಗಿಸಿದ್ದೇನೆ.

669
00:35:51,030 --> 00:35:52,130
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ] ಐದು?

670
00:35:52,130 --> 00:35:53,990
>> ಡಾನ್: ಹಲೋ ಐದು ಎಂದು.

671
00:35:53,990 --> 00:35:55,240
ಹೌದು.

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
ಆದ್ದರಿಂದ ಸರಣಿಗಳ ನಿರಂತರವಾಗಿವೆ
ಮೆಮೊರಿಯ ಬ್ಲಾಕ್ಗಳನ್ನು.

674
00:36:02,880 --> 00:36:08,480
ಅವರು ಹೇಳುವ ಮೂಲಕ ದಿಢೀರ್
ಕರ್ಲಿ ರಲ್ಲಿ, ರಚನೆಯ ಹೆಸರು ಮತ್ತು ನಂತರ

675
00:36:08,480 --> 00:36:16,720
ನೀವು ಹೋಗಿ ಬಯಸುವ ಯಾವುದೇ ಸೂಚ್ಯಂಕ ಕಟ್ಟುಪಟ್ಟಿಗಳು,
ಅವರು ಮೂಲಕ ಶೂನ್ಯ ಸೂಚ್ಯಂಕದೊಡನೆ ಮಾಡುತ್ತಿದ್ದೇವೆ ಗೆ

676
00:36:16,720 --> 00:36:20,100
1 ಮೈನಸ್ ರಚನೆಯ ಉದ್ದ.

677
00:36:20,100 --> 00:36:23,070
>> ಅವರು ಮಾದರಿ ಘೋಷಿಸುವ ಮಾಡುತ್ತಿದ್ದೇವೆ
ನೀವು ಸಂಗ್ರಹಿಸಲು ನೀವು ವಿಷಯ

678
00:36:23,070 --> 00:36:29,750
ರಚನೆಯ ರಚನೆಯ ಹೆಸರು, ಮತ್ತು ನಂತರ
ಯಾವುದೇ ಗಾತ್ರದ ರಚನೆಯ ಹೊಂದಿದೆ.

679
00:36:29,750 --> 00:36:36,660
ಆದ್ದರಿಂದ ಈ ಉದ್ದದ ಚಾರ್ ರಚನೆಯ ಹೊಂದಿದೆ
ಈ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಆರು.

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
ಹೌದು?

682
00:36:42,700 --> 00:36:43,950
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> ಡಾನ್: ಹೌದು.

685
00:36:48,460 --> 00:36:51,340
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

686
00:36:51,340 --> 00:36:56,700
>> ಡಾನ್: ನೀವು ಏನಾಗುತ್ತಿದೆ ಹೊಂದಿದ್ದರೆ
ಸರಣಿ ಈಗಾಗಲೇ ಮಾಡಿದ.

687
00:36:56,700 --> 00:37:02,260
ಆದ್ದರಿಂದ ನೀವು ಬದಲಿಗೆ ಈ ಸೂಚಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ,
ಸೇ, ಚಾರ್, ಏನೇ ಹೆಸರು ನಿಮ್ಮ

688
00:37:02,260 --> 00:37:12,200
ಸರಣಿ ಖಾಲಿ ಆವರಣ ಕರ್ಲಿ ಸಮನಾಗಿರುತ್ತದೆ, ಆಗಿದೆ
ಎಚ್ ಅಲ್ಪವಿರಾಮ ಇ ಅಲ್ಪವಿರಾಮ ಎಲ್ ಅಲ್ಪವಿರಾಮ ಎಲ್ ಅಲ್ಪವಿರಾಮ ಬ್ರೇಸ್

689
00:37:12,200 --> 00:37:16,290
ಓ ಅಲ್ಪವಿರಾಮ ಶೂನ್ಯಚಿಹ್ನೆ
ಮತ್ತು ಸುರುಳಿಯಾದ ಬ್ರೇಸ್.

690
00:37:16,290 --> 00:37:18,180
ಸಹ ಘೋಷಣೆ ಕೆಲಸ ಎಂದು.

691
00:37:18,180 --> 00:37:20,886
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

692
00:37:20,886 --> 00:37:23,110
>> ಡಾನ್: ನಂತರ ನೀವು ಮಾಡಬೇಕು
ಗಾತ್ರ ಈಗಾಗಲೇ ಮಾಡಿದ.

693
00:37:23,110 --> 00:37:23,896
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

694
00:37:23,896 --> 00:37:25,146
>> ಡಾನ್: ಹೌದು.

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
ಎಲ್ಲಾ righty.

697
00:37:32,420 --> 00:37:36,430
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ
ಬಳಕೆದಾರ ಮಾಹಿತಿ ಇನ್ಪುಟ್ ಪಡೆಯುವಲ್ಲಿ

698
00:37:36,430 --> 00:37:39,380
ಮುಖ್ಯ ಚರ್ಚೆಗಳು.

699
00:37:39,380 --> 00:37:40,600
ಮುಖ್ಯ ಎರಡು ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

700
00:37:40,600 --> 00:37:47,680
ವಾಗಿದೆ ಎಂದು ವಾದಗಳನ್ನು ಸಂಖ್ಯೆಯನ್ನು
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಒಂದು ಹರಿಯಬಿಡುವುದು

701
00:37:47,680 --> 00:37:55,340
ಸ್ಟ್ರಿಂಗ್ ವೆಕ್ಟರ್ ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ರಚನೆ
ವಾದಗಳಲ್ಲಿ ಎಲ್ಲಾ.

702
00:37:55,340 --> 00:38:07,840
>> ಹಾಗಾಗಿ, ಹೇಳುತ್ತಾರೆ, ಉದಾಹರಣೆಗೆ ಒಂದು ಕ್ರಿಯೆ ಎಂದು ವೇಳೆ
1 ಸ್ಥಳವನ್ನು 2 ಸ್ಥಳವನ್ನು ಮೂರು ಔಟ್ ಒಂದು ಬಿಂದುವನ್ನು,

703
00:38:07,840 --> 00:38:10,110
argc, 4 ಎಂದು.

704
00:38:10,110 --> 00:38:17,370
ಮತ್ತು argv 0 ಔಟ್ ಒಂದು ಡಾಟ್ ಎಂದು.

705
00:38:17,370 --> 00:38:19,130
Argv1 1 ಎಂದು.

706
00:38:19,130 --> 00:38:23,030
argv2 2 argv3 ಎಂದು ಎಂದು
3, ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭದಲ್ಲಿ.

707
00:38:23,030 --> 00:38:23,310
ಹೌದು?

708
00:38:23,310 --> 00:38:25,400
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

709
00:38:25,400 --> 00:38:34,010
>> ಡಾನ್: ರಚನೆಯ ಕೊನೆಯ ಅಂಶ
ಶ್ರೇಣಿಯನ್ನು ಉದ್ದ argc, ಏಕೆಂದರೆ ಜೊತೆಗೆ

710
00:38:34,010 --> 00:38:41,050
argb ಒಂದು, ಕೊನೆಯ ಅಂಶ
ನಲ್ ಪಾಯಿಂಟರ್ ಹೊಂದಿದೆ.

711
00:38:41,050 --> 00:38:42,580
ಇದು argc, ಜೊತೆಗೆ 1 ಆಗಿದೆ.

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
ನಾನು, ಇದು ಹೇಳಿದರು ಸಂದರ್ಭದಲ್ಲಿ
0 argv ಎಂದು ಔಟ್ ಒಂದು ಬಿಂದುವನ್ನು ಹೊಂದಿದೆ.

714
00:38:52,150 --> 00:38:56,330
, argv 1 1 argv2 3 3 2, argv ಆಗಿದೆ.

715
00:38:56,330 --> 00:39:03,490
ಒಂದು ದೊಡ್ಡ ಇದು, argv 4,
argc, ಹೆಚ್ಚು ಶೂನ್ಯ ಎಂದು.

716
00:39:03,490 --> 00:39:04,870
>> ಮತ್ತು ನಲ್ ಪಾಯಿಂಟರ್ ಇಲ್ಲಿದೆ.

717
00:39:04,870 --> 00:39:06,590
ಹೌದು.

718
00:39:06,590 --> 00:39:11,250
ಸ್ಟ್ರಿಂಗ್ ಕಾರಣ ಎಂದು ಇಲ್ಲಿದೆ
ಚಾರ್ ಸ್ಟಾರ್ ಸೂಚಿಯಾಗಿದೆ.

719
00:39:11,250 --> 00:39:14,102
ಆದ್ದರಿಂದ ಅದೇ ರೀತಿಯ ಇರಬೇಕು.

720
00:39:14,102 --> 00:39:14,595
ಹೌದು?

721
00:39:14,595 --> 00:39:16,074
>> ಪ್ರೇಕ್ಷಕರು: ಎರಡು ಪ್ರಶ್ನೆಗಳನ್ನು.

722
00:39:16,074 --> 00:39:21,004
ಆದ್ದರಿಂದ, ವ್ಯತ್ಯಾಸ ನಡುವೆ ಎಂಬುದನ್ನು
ಒಂದು ರೀತಿಯ ಬೇರೆ ಈ ಮತ್ತು GetString

723
00:39:21,004 --> 00:39:22,483
ಬಳಕೆದಾರ ಎಂಜಿನ್?

724
00:39:22,483 --> 00:39:25,934
ಮತ್ತು ಎರಡು, ಇದು ಒಳಗೆ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ
ನಿಮ್ಮ ಇತ್ತೀಚಿನ ಮೆಮೊರಿ?

725
00:39:25,934 --> 00:39:28,399
ಆದ್ದರಿಂದ ಹಾಗೆ,, GetString ಎಂದು
[ಕೇಳಿಸುವುದಿಲ್ಲ] ಎಂದು?

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> ಡಾನ್: ಅಲ್ಲಿ ಇದು ಸಂಗ್ರಹವಾಗಿರುವ ಇದೆ?

728
00:39:33,650 --> 00:39:34,905
ಇದು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಅಲ್ಲಿ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

729
00:39:34,905 --> 00:39:40,000
>> ಪ್ರೇಕ್ಷಕರು: ಆದ್ದರಿಂದ, ವಾಸ್ತವವಾಗಿ, ನೀವು ಹೇಗೆ ಯಾವುದೇ ಗೊತ್ತು
ನೀವು ವಾದಗಳು ಇಲ್ಲಿದೆ ಕರೆ ಕಾರ್ಯಕ್ಕೆ

730
00:39:40,000 --> 00:39:42,170
ಸ್ಟಾಕ್ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ?

731
00:39:42,170 --> 00:39:46,610
ಆದ್ದರಿಂದ argc ಮತ್ತು argv ವಾದಗಳು ಮುಖ್ಯ ಮಾಡುವುದು
ಮತ್ತು ಅವರು ಸ್ಟಾಕ್ ಇರುತ್ತವೆ, ಅಥವಾ ನಿಜವಾಗಿಯೂ

732
00:39:46,610 --> 00:39:49,131
ಕೇವಲ ನೀವು ಅನಿಸಿಕೆಗಳನ್ನು ಮೇಲೆ
ಸ್ಟಾಕ್ ಆರಂಭದಲ್ಲಿ.

733
00:39:49,131 --> 00:39:53,490
ಇತರ ಭಾಗ ಯಾವುದು
ಪ್ರಶ್ನೆ?

734
00:39:53,490 --> 00:39:56,821
>> ಪ್ರೇಕ್ಷಕರು: ಇಲ್ಲಿದೆ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

735
00:39:56,821 --> 00:40:00,990
>> ಡಾನ್: ಹೌದು, ಇದು ಕೇವಲ ಒಂದು ವಿಭಿನ್ನ ರೀತಿಯಲ್ಲಿ ಇಲ್ಲಿದೆ
ನ ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯುವಲ್ಲಿ.

736
00:40:00,990 --> 00:40:06,030
ಈ ಒಂದು ತಂದೆಯ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಮತ್ತು
ಇದು ಲಿಪಿಗಳು handier ನೀವು ಏಕೆಂದರೆ

737
00:40:06,030 --> 00:40:10,070
ನಿಮ್ಮ ಮುಖ್ಯ ಚರ್ಚೆಗಳು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ
ಕಾರ್ಯ ಬದಲಿಗೆ ನಿರೀಕ್ಷಿಸಿ ಮೂಲಕ ಹೆಚ್ಚು

738
00:40:10,070 --> 00:40:13,400
ಬಳಕೆದಾರರಿಗೆ ನೀವು ಯಾವುದೇ ಬಳಕೆದಾರರು ಹೊಂದಿಲ್ಲ.

739
00:40:13,400 --> 00:40:16,280
>> ಪ್ರೇಕ್ಷಕರು: ಹೌದು ತಂತಿಗಳ ಪಡೆಯಲು
[ಕೇಳಿಸುವುದಿಲ್ಲ] ಎಂದು.

740
00:40:16,280 --> 00:40:17,922
ಇದು ನೀವು ವಿಷಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ಎಂದು.

741
00:40:17,922 --> 00:40:18,834
>> ಡಾನ್: ಹೌದು?

742
00:40:18,834 --> 00:40:21,114
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

743
00:40:21,114 --> 00:40:27,545
>> ಡಾನ್: ಹೌದು ಮತ್ತು, argv 0 ಯಾವಾಗಲೂ ಒಳಗೊಂಡಿದೆ
ಡಾಟ್ ಕಾರ್ಯ ಕರೆಯ ಕಡಿದು.

744
00:40:27,545 --> 00:40:28,042
ಹೌದು?

745
00:40:28,042 --> 00:40:29,292
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> ಡಾನ್: ಹೌದು, ಪ್ರತಿಯೊಂದು ವಾದದ ಇವೆ
ಶೂನ್ಯಚಿಹ್ನೆ ಕೊನೆಗೊಂಡಿತು ಅವರು ಕಾರಣ

748
00:40:37,310 --> 00:40:38,310
ತಂತಿಗಳು.

749
00:40:38,310 --> 00:40:40,892
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

750
00:40:40,892 --> 00:40:44,116
>> ಡಾನ್: ಹೌದು ಮತ್ತು, argv argc, ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್.

751
00:40:44,116 --> 00:40:45,112
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

752
00:40:45,112 --> 00:40:47,104
>> ಡಾನ್: ಹೌದು.

753
00:40:47,104 --> 00:40:48,100
ಹೌದು, ಕ್ಷಮಿಸಿ.

754
00:40:48,100 --> 00:40:49,594
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> ಡಾನ್: ನೀವು ಹೊಂದಿದ್ದರೆ ಪ್ರಶ್ನೆ ಆದ್ದರಿಂದ
ಆಜ್ಞಾ ಸಾಲಿನ ಡಾಟ್, 2, 1 ಔಟ್ ಒಂದು ಡಾಟ್ ಕತ್ತರಿಸಿ

757
00:41:16,340 --> 00:41:20,410
ಎಂದು ಆಜ್ಞಾ ಸಾಲಿನ ಸಂಖ್ಯೆ
ವಾದಗಳು ಎರಡು ಅಥವಾ ಮೂರು ಎಂದು?

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> ಪ್ರೇಕ್ಷಕರು: ನಾನು ಭಾವಿಸುತ್ತೇನೆ
ಪರವಾಗಿಲ್ಲ.

760
00:41:28,240 --> 00:41:31,370
ನಾನು ಓಹ್, ನೀವು ಪೂರೈಸಲಿಲ್ಲ, ಹೇಳುವ ಪ್ರವೃತ್ತಿ
ಆಗ ಈ ಮೌಲ್ಯಗಳನ್ನು,

761
00:41:31,370 --> 00:41:32,730
ನಿಸ್ಸಂಶಯವಾಗಿ, ನೀವು ಕಾರ್ಯ ಎಂದು.

762
00:41:32,730 --> 00:41:37,950
ಹಾಗಾಗಿ ಬಹುತೇಕ ಹಾಕುವಂತೆ ಒಲವು
ಆಜ್ಞಾ ಸಾಲಿನಿಂದ ಕಾರ್ಯ

763
00:41:37,950 --> 00:41:40,350
ಇದು ಸಹ ವಾದಗಳನ್ನು
, argv ಒಳಗೊಂಡಿತ್ತು.

764
00:41:40,350 --> 00:41:42,600
>> ಡಾನ್: ಆದರೆ test-- ಮೇಲೆ ವೇಳೆ

765
00:41:42,600 --> 00:41:46,550
yeah-- ಮತ್ತು ನೀವು ಏನನ್ನಾದರೂ ಹೇಳಲು ವೇಳೆ
argc, 3 ಸಮನಾಗಿರುತ್ತದೆ ಹಾಗೆ,

766
00:41:46,550 --> 00:41:48,512
ನೀವು ಸುರಕ್ಷಿತ ನಿಂತಿರುವ ಆರ್.

767
00:41:48,512 --> 00:41:49,416
ಹೌದು?

768
00:41:49,416 --> 00:41:50,666
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> ಡಾನ್: ನಾನು ಬದಲಿಗೆ ಈ ಕರೆ ನಗರದ
argc ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ argv ಆವರಣಗಳಲ್ಲಿ

771
00:42:09,510 --> 00:42:14,350
ಆದರೆ ಅದೇ ರೀತಿಯ ಇದ್ದರು ಮತ್ತು ಕೇವಲ ಎಂದು
ಒಂದು ರೀತಿಯ ವಿಭಿನ್ನ ಏನೋ

772
00:42:14,350 --> 00:42:16,640
ಮತ್ತು ಬಿ, ಇದು ಇನ್ನೂ ಕೆಲಸ?

773
00:42:16,640 --> 00:42:18,790
ಮತ್ತು ಇದು ಈಗಲೂ ಕೆಲಸ,
ನೀವು ಕೇವಲ ಮಾಡಬಹುದು ಎಂದು

774
00:42:18,790 --> 00:42:21,520
ಬದಲಿಗೆ argc-- ಬಳಸುವ
ನೀವು ಒಂದು ಮತ್ತು ಬಿ ಬಳಸಲು ಬಯಸುವ.

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
ಹೌದು?

777
00:42:25,408 --> 00:42:26,658
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> ಡಾನ್: ಪ್ರಶ್ನೆ, GetString ಆಗಿದೆ
ಹೇರಳ ಮೆಮೊರಿ ಶೇಖರಿಸಿಡಬೇಕು

780
00:42:38,850 --> 00:42:42,280
GetString ಚಾರ್ ಏಕೆಂದರೆ *.

781
00:42:42,280 --> 00:42:47,530
ಇದು ಏಕೆಂದರೆ ಹೇರಳ ಮೆಮೊರಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ
ನಿಜವಾದ ಒಳಗೆ ಈಗ malloc ಅಪೇಕ್ಷಿಸುವ

782
00:42:47,530 --> 00:42:49,258
GetString ಅನುಷ್ಠಾನಕ್ಕೆ.

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
ಸರಿ, ಮೇಲೆ ಚಲಿಸುವ.

785
00:42:55,090 --> 00:42:55,950
>> ಭದ್ರತಾ.

786
00:42:55,950 --> 00:43:01,090
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ಸುರಕ್ಷಿತವಾಗಿರಬೇಕೆಂದರೆ, ನೀವು ಯಾವುದೇ ಅವಲಂಬಿಸಿವೆ
ಒಂದು ಮತ್ತು ನೀವು ಯಾವುದೇ ಯಾರೂ ಅನುಮತಿಸಬಹುದು

787
00:43:01,090 --> 00:43:04,540
ನಿಮ್ಮ ಮಾಹಿತಿ, ಯಾವ ಏಕೆ
ಎಲ್ಲರೂ, ತಮ್ಮ ವಾಹನಗಳನ್ನು ನಿರ್ಮಿಸುವ

788
00:43:04,540 --> 00:43:09,580
ತಮ್ಮ ಕಾರ್ಯವ್ಯವಸ್ಥೆಗಳನ್ನು ತಮ್ಮ
ಆರಂಭದಿಂದ ಕಾರ್ಯಕ್ರಮಗಳು, ಮತ್ತು ನಿಸ್ಸಂಶಯವಾಗಿ

789
00:43:09,580 --> 00:43:13,410
ಯಾವುದೇ ಯಂತ್ರಗಳು ಸಂಪರ್ಕ ಇಲ್ಲ
ಇಂಟರ್ನೆಟ್ ಮೂಲಕ.

790
00:43:13,410 --> 00:43:17,350
ಆದ್ದರಿಂದ ಕಂಪ್ಯೂಟರ್ ಅಸುರಕ್ಷಿತವಾಗಿವೆ.

791
00:43:17,350 --> 00:43:19,200
ಅವರು ನಿಜವಾಗಿಯೂ ಅವು.

792
00:43:19,200 --> 00:43:20,940
ನಾವು ಇತರ ಜನರು ನಂಬಲು ಹೊಂದಿವೆ.

793
00:43:20,940 --> 00:43:26,500
>> ಮತ್ತು ಭದ್ರತಾ ಕಲ್ಪನೆಯನ್ನು ನೀವು ಕೋರುತ್ತೇವೆ ಎಂದು
ಪ್ರಮಾಣವನ್ನು ಸೀಮಿತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

794
00:43:26,500 --> 00:43:27,540
ನೀವು ಟ್ರಸ್ಟ್.

795
00:43:27,540 --> 00:43:32,080
ಮತ್ತು ಮಾಧ್ಯಮವಾಗಿದೆ ನೀವು ಹಾಗೆ
ಗೂಢಲಿಪಿಶಾಸ್ತ್ರ ಮೂಲಕ.

796
00:43:32,080 --> 00:43:34,950
ಕ್ರಿಪ್ಟೋಗ್ರಾಫಿ ಮೂಲಭೂತವಾಗಿ,
ನಾವು ರಹಸ್ಯಗಳನ್ನು ಹೊಂದಿವೆ.

797
00:43:34,950 --> 00:43:38,880
>> ಕೆಲವೊಮ್ಮೆ ನಾವು ರಹಸ್ಯವನ್ನು ಪಾಸ್ ಮಾಡಬೇಕು
ಜೊತೆಗೆ ಮೂಲಕ, ಹೇಳುತ್ತಾರೆ, ಇಂಟರ್ನೆಟ್ ಅಥವಾ

798
00:43:38,880 --> 00:43:39,980
ಇತರ ವಿಷಯಗಳು.

799
00:43:39,980 --> 00:43:43,180
ನಾವು ಜನರು ಬಯಸುವುದಿಲ್ಲ
ಈ ರಹಸ್ಯಗಳನ್ನು ತಿಳಿಯಲು.

800
00:43:43,180 --> 00:43:50,100
ನಾವು ಒಂದು ರೀತಿಯಲ್ಲಿ ನಮ್ಮ ರಹಸ್ಯಗಳನ್ನು ಎನ್ಕ್ರಿಪ್ಟ್
ನಾವು ಯಾರೂ ಊಹಿಸಲು ನಂಬಿಕೆ.

801
00:43:50,100 --> 00:43:51,600
>> ನಾವು used--

802
00:43:51,600 --> 00:43:54,340
ಈ class-- ಕೋರ್ಸ್ ಮೂಲಕ

803
00:43:54,340 --> 00:44:00,750
ಸೀಸರ್ ಸೈಫರ್ ವಿಷಯಗಳನ್ನು ಮತ್ತು
ಎರಡೂ ತುಂಬಾ ಇವು [ಕೇಳಿಸುವುದಿಲ್ಲ],

804
00:44:00,750 --> 00:44:03,200
ವಿಷಯಗಳನ್ನು ಗೂಢಲಿಪೀಕರಿಸಲಾಗುತ್ತದೆ ಅಸುರಕ್ಷಿತ ರೀತಿಯಲ್ಲಿ.

805
00:44:03,200 --> 00:44:07,930
ಅವರು ಲೆಕ್ಕಾಚಾರ ಸುಲಭವಾಗಿ ಏನನ್ನು ಅವರು
ಮತ್ತು ನಿಮ್ಮ ರಹಸ್ಯಗಳನ್ನು ಯಾವುವು.

806
00:44:07,930 --> 00:44:12,130
ನೈಜ ಹೆಚ್ಚು ಬಳಸುತ್ತದೆ
ಸಂಕೀರ್ಣ ಗೂಢಲಿಪೀಕರಣ ಯೋಜನೆಗಳು.

807
00:44:12,130 --> 00:44:13,880
ನಾವು ಸಿಗುವುದಿಲ್ಲ
ಎಂದು ಹೆಚ್ಚು.

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> ಡೀಬಗ್.

810
00:44:19,430 --> 00:44:20,785
GDB, ಉತ್ತಮ.

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
ನಾನು ಮತ್ತೆ ಈ ಒತ್ತು ಪಡೆಯಲಿದ್ದೇನೆ.

813
00:44:25,810 --> 00:44:30,920
GDB, ಸಾರ್ವಕಾಲಿಕ ಪ್ರತಿ ಬಳಸಿ
ಸಮಯ ನೀವು ಸಮಸ್ಯೆ.

814
00:44:30,920 --> 00:44:36,030
GDB ರಲ್ಲಿ ಉಪಯುಕ್ತ ಆಜ್ಞೆಗಳನ್ನು
ನೀವು ತಂತಿಯಾಗಿರುತ್ತದೆ ಬರಬಹುದಾದ, ಮುರಿಯಲು

815
00:44:36,030 --> 00:44:41,330
ಸಂಖ್ಯೆ, ಒಂದು ಕ್ರಿಯೆ ಹೆಸರು, ಮೂಲಭೂತವಾಗಿ
ಅಲ್ಲಿ ನಿಮ್ಮ ಕೋಡ್ ನಲ್ಲಿ ನೀವು ನಿಲ್ಲಿಸಲು ಬಯಸುವ,

816
00:44:41,330 --> 00:44:45,600
ಮತ್ತು ನಿಯಂತ್ರಣ ಪಡೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

817
00:44:45,600 --> 00:44:54,140
>> ಪ್ರಿಂಟ್ ವೇರಿಯಬಲ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ
ವೇರಿಯಬಲ್ ಆ ಏನೇ

818
00:44:54,140 --> 00:44:55,990
ನಿಮ್ಮ ನಡೆಸುವಲ್ಲಿ ಪಾಯಿಂಟ್.

819
00:44:55,990 --> 00:45:00,130
ಮುಂದೆ ನಿಮ್ಮ ಮರಣದಂಡನೆ ಚಲಿಸುತ್ತದೆ
ಒಂದು ಹೆಜ್ಜೆ ಜೊತೆಗೆ.

820
00:45:00,130 --> 00:45:05,050
ಮತ್ತು ಕಾರ್ಯ ಒಳಗೆ ಕ್ರಮಗಳನ್ನು ಹೆಜ್ಜೆ
ನಿಮ್ಮ ನಡೆಸುವಲ್ಲಿ.

821
00:45:05,050 --> 00:45:10,480
>> ಇತರೆ ವಿಷಯಗಳನ್ನು ಹೇಗೆ, ನಡೆಸುತ್ತವೆ
ನೀವು ವಾಸ್ತವವಾಗಿ ನಿಮ್ಮ ಕೋಡ್ ರನ್.

822
00:45:10,480 --> 00:45:16,630
ಮುಂದುವರಿಸಿ ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಮುಂದಿನ ಬ್ರೇಕ್ ಪಾಯಿಂಟ್ ಪಡೆಯಲು.

823
00:45:16,630 --> 00:45:18,300
ಮತ್ತು ಅನೇಕ, ಅನೇಕರು ಇವೆ.

824
00:45:18,300 --> 00:45:19,040
ಅವುಗಳನ್ನು ನೋಡಿ.

825
00:45:19,040 --> 00:45:19,901
ಅವರು ಆರ್.

826
00:45:19,901 --> 00:45:20,863
ಹೌದು?

827
00:45:20,863 --> 00:45:22,113
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> ಡಾನ್: ಹೌದು, ಒಂದು ದೋಷಸೂಚಕವು ಇದು.

830
00:45:28,200 --> 00:45:34,230
ಆದ್ದರಿಂದ ದೋಷನಿವಾರಕದ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಎಂದು
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ದೋಷ ಅನುಮತಿಸುತ್ತದೆ.

831
00:45:34,230 --> 00:45:39,931
ಇದು ದೋಷಗಳನ್ನು ಕಂಡುಹಿಡಿಯುವ ಪ್ರೋಗ್ರಾಂ ಅಲ್ಲ
ನೀವು, ಆದರೂ ಆ ಉತ್ತಮ ಎಂದು.

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> ಮತ್ತು ಹುಡುಕಾಟ ನನಗೆ ಕಳೆದ ಆಗಿದೆ.

834
00:45:46,040 --> 00:45:51,470
ನಾವು ಮಾತನಾಡಿದರು ಹುಡುಕಾಟ ರೀತಿಯ ಆದ್ದರಿಂದ
ಈ ವರ್ಗದ ಬಗ್ಗೆ ರೇಖೀಯ ಹುಡುಕಾಟ ಇವೆ,

835
00:45:51,470 --> 00:45:55,960
ಇದು ನೀವು ಪ್ರತಿ ಮೂಲಕ ಕಾಣುವ ಕೇವಲ ಆಗಿದೆ
ಶೋಧ ಅಂಶ, ಒಂದು

836
00:45:55,960 --> 00:46:00,410
ಒಂದು ಸಮಯದಲ್ಲಿ ಅಂಶ, ನೀವು ಹುಡುಕಲು ವರೆಗೆ
ನೀವು ಅಥವಾ ನೀವು ತಲುಪುವವರೆಗೆ ಹುಡುಕುತ್ತಿರುವ

837
00:46:00,410 --> 00:46:03,350
ನಿಮ್ಮ ಶೋಧ ಕೊನೆಯಲ್ಲಿ ಇದು
ನೀವು ದೊರೆತಿಲ್ಲ ಎಂದು ಹೇಳಲು ತೋರಿಸಲು

838
00:46:03,350 --> 00:46:06,360
ನೀವು ಹುಡುಕುತ್ತಿರುವ ಆ ಅಂಶ.

839
00:46:06,360 --> 00:46:13,450
ಮತ್ತು ಈ, ಅತ್ಯುತ್ತಮ ಸ್ಥಿರ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಇದು 1 0 ಮತ್ತು ಕೆಟ್ಟ ರೇಖೀಯ ನಲ್ಲಿ

840
00:46:13,450 --> 00:46:16,070
n ನ 0 ಇದು ಸಮಯ,.

841
00:46:16,070 --> 00:46:19,250
>> ಅಗತ್ಯವಿದೆ ಬೈನರಿ ಸರ್ಚ್,
ಜಿಪುಣತನದ ಅಂಶಗಳನ್ನು.

842
00:46:19,250 --> 00:46:24,230
ನಿಮ್ಮ ಅಂಶಗಳ ಮಧ್ಯಮ ಹೋಗಿ,
ನೋಡಿ ನೀವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ

843
00:46:24,230 --> 00:46:30,120
ಅಂಶ ದೊಡ್ಡ ಅಥವಾ ಸಣ್ಣ ಆಗಿದೆ
ನೀವು ಮಧ್ಯಮ ಎಂಬುದನ್ನು.

844
00:46:30,120 --> 00:46:36,510
ಇದು ದೊಡ್ಡ ಇಲ್ಲಿದೆ, ನೀವು ಕೆಳಗೆ ಎಂದು ಹೇಳಲು
ನಿಮ್ಮ ಹುಡುಕಾಟ ಅಂತರದಲ್ಲಿ ನಿಮ್ಮ ಆಗಿದೆ

845
00:46:36,510 --> 00:46:41,550
ಪ್ರಸ್ತುತ ಸ್ಥಳ, ಮಧ್ಯಮ,
ಮತ್ತು ನೀವು ಕಾರ್ಯವನ್ನು ಮತ್ತೆ.

846
00:46:41,550 --> 00:46:46,150
ಇದು ಸಣ್ಣ, ನೀವು ಹೇಳಲು ನೋಡಲು
ಹೌದು, ಹೇಗಿದ್ದೀರಿ ಮುಚ್ಚಲಿದೆ ಎಂದು?

847
00:46:46,150 --> 00:46:47,400
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> ಡಾನ್: ಹೌದು.

850
00:46:54,260 --> 00:46:58,360
ನಲ್ಲಿ ಕಲಿಸಿದ ಆ ರೀತಿಯ ಯಾವುದೇ ರೀತಿಯ
ವರ್ಗ ಪರೀಕ್ಷೆಗೆ ನ್ಯಾಯಯುತ ಆಟ.

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [ನಗು]

853
00:47:04,920 --> 00:47:10,260
>> ಡಾನ್: ಮತ್ತು ನೀವು ಹೊಂದಿಲ್ಲ ಎಂದು ವಾಸ್ತವವಾಗಿ
ಸಮಸ್ಯೆ ಸೆಟ್ ಅದನ್ನು ಮಾಡಲು, ನ್ಯಾಯಯುತ

854
00:47:10,260 --> 00:47:12,420
ಪರೀಕ್ಷೆಗೆ ಆಟದ.

855
00:47:12,420 --> 00:47:15,186
>> ಪ್ರೇಕ್ಷಕರು: ನಾವು ಅದನ್ನು ಹೋಗಿ ಹೇಗೆ to--

856
00:47:15,186 --> 00:47:17,052
>> ಡಾನ್: ಇದು ಮೇಲೆ ಹೋಗುತ್ತವೆ.

857
00:47:17,052 --> 00:47:20,496
>> ಸ್ಪೀಕರ್ 2: ನಿಜವಾದ ಕೋಡ್
[ಕೇಳಿಸುವುದಿಲ್ಲ] study.cs50.net ಮೇಲೆ.

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
ನೀವು ಅಭ್ಯಾಸ ಸಮಸ್ಯೆ ನೋಡಲು ಆದ್ದರಿಂದ
ಆಫ್ ವಿಲೀನ ರೀತಿಯ ಪುಟದಲ್ಲಿ

860
00:47:32,680 --> 00:47:35,880
study.cs50.net, ಕೋಡ್ ಇಲ್ಲ
ವಿಲೀನ ಅನುಷ್ಠಾನಕ್ಕೆ.

861
00:47:35,880 --> 00:47:38,550
ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಲ್ಲ
ಇದು ನಿಮ್ಮನ್ನು ಟುನೈಟ್.

862
00:47:38,550 --> 00:47:42,090
ಆದರೆ ನೀವು ಬದಲಿಗೆ ಇದು ಅರ್ಥಮಾಡಿಸಲು
ಕೇವಲ ಇದು ಮನನ.

863
00:47:42,090 --> 00:47:45,035
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

864
00:47:45,035 --> 00:47:49,720
>> ಸ್ಪೀಕರ್ 2: ಮೇಲೆ ವಿಲೀನ ರೀತಿಯ ಪುಟ
study.cs50.net, ಅಭ್ಯಾಸ ಇಲ್ಲ

865
00:47:49,720 --> 00:47:53,570
ನೀವು ಮೂಲಕ ಕ್ಲಿಕ್ ಮಾಡಿ, ಸಮಸ್ಯೆ
ಸಮಸ್ಯೆ, ಅತ್ಯಂತ ಕೊನೆಯಲ್ಲಿ ಇಲ್ಲ ಒಂದು

866
00:47:53,570 --> 00:47:56,280
ವಿಲೀನ ಇದು ಪರಿಹಾರ,
ರೀತಿಯ ಅನುಷ್ಠಾನ.

867
00:47:56,280 --> 00:47:58,510
ಆದರೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅರ್ಥವಾಗಿ
ಕೇವಲ ಇದು ಮನನ ಹೆಚ್ಚು

868
00:47:58,510 --> 00:47:59,760
ಅಥವಾ ಅದನ್ನು ನಕಲು.

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> ಪ್ರೇಕ್ಷಕರು: ಒಂದು ಸಂಪೂರ್ಣವಾಗಿ ಮಾನ್ಯ
ಪರೀಕ್ಷೆಗಾಗಿ ಸಮಸ್ಯೆ ಎಂದು

871
00:48:06,340 --> 00:48:07,990
ಇಲ್ಲಿ ರೀತಿಯ ಒಂದು ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.

872
00:48:07,990 --> 00:48:12,100
ಈ ಪಟ್ಟಿಯನ್ನು ನಂತರ ರೀತಿ ಮಾಡುವುದಿಲ್ಲ ಏನು
ಆಯ್ಕೆಗಳನ್ನು ರೀತಿಯ ಒಂದು ಹೆಜ್ಜೆ ಅಥವಾ

873
00:48:12,100 --> 00:48:13,330
ಅಳವಡಿಕೆಯ ರೀತಿಯ ಅಥವಾ ಯಾವುದೇ.

874
00:48:13,330 --> 00:48:14,940
ಪಟ್ಟಿಯ ಒಂದು ಪೂರ್ಣ ಪುನರಾವರ್ತನೆ.

875
00:48:14,940 --> 00:48:18,530
ನಿಮಗೆ ಅಗತ್ಯವಿಲ್ಲದೇ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಆದ್ದರಿಂದ ಸಹ
ಇದು ಕೋಡ್, ನೀವು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಬೇಕು

876
00:48:18,530 --> 00:48:20,440
ಇದು ವಿಶೇಷವೇನು ಹೇಗೆ ತಿಳಿಯಲು ಸಾಕಷ್ಟು
ಈ ರಚನೆಯ ಮಾರ್ಪಡಿಸುವ ಎಂದು.

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> ಡಾನ್: ನನಗೆ ಅಷ್ಟೇ.

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [ಚಪ್ಪಾಳೆಯನ್ನು]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> LUCAS: ಹೇ ಎಲ್ಲರೂ.

883
00:49:07,410 --> 00:49:08,390
ನನ್ನ ಹೆಸರು ಲ್ಯೂಕಾಸ್ ಹೊಂದಿದೆ.

884
00:49:08,390 --> 00:49:16,840
ನಾನು ಎಲ್ಲಾ, ಪುನರಾವರ್ತನ ಬಗ್ಗೆ ಮಾತನಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ
ನಾವು ಕಲಿತ ಎಂದು ರೀತಿಯ, ಮತ್ತು ಒಂದು

885
00:49:16,840 --> 00:49:18,050
ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ಸ್ ಸ್ವಲ್ಪ.

886
00:49:18,050 --> 00:49:18,740
ಸರಿ?

887
00:49:18,740 --> 00:49:20,340
ಎಲ್ಲಾ ಆದ್ದರಿಂದ ಮೊದಲ, ಪುನರಾವರ್ತನ.

888
00:49:20,340 --> 00:49:22,951
ಇದು ಎಂದು ಹೇಳಲು ಏನು
ಒಂದು ಫಂಕ್ಷನ್ ಪುನರಾವರ್ತಿತ ಹೊಂದಿದೆ?

889
00:49:22,951 --> 00:49:24,675
>> ಪ್ರೇಕ್ಷಕರು: ಸ್ವತಃ ಕರೆಯುತ್ತದೆ.

890
00:49:24,675 --> 00:49:26,500
>> LUCAS: ಸರಿ, ಹೌದು, ಸ್ವತಃ ಕರೆಗಳನ್ನು.

891
00:49:26,500 --> 00:49:27,700
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ ಈ ಚಿತ್ರವನ್ನು, ಹಾಗೆ.

892
00:49:27,700 --> 00:49:30,280
ಇದು ಒಳಗೆ ಚಿತ್ರ ಹೀಗಿದೆ
ಒಂದು ಚಿತ್ರದ ಹೀಗೆ.

893
00:49:30,280 --> 00:49:35,740
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನೀವು ಡಾನ್ ಹೊಂದಬಹುದು
ಬೈನರಿ ಸರ್ಚ್ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೆ.

894
00:49:35,740 --> 00:49:41,840
ಇದು ಒಂದು ರೀತಿಯಲ್ಲಿ ಬೈನರಿ ಸರ್ಚ್
ಪುನರಾವರ್ತಿತ ನೀವು ಸಂಗತಿಯೆಂದರೆ

895
00:49:41,840 --> 00:49:43,130
ಹಲವಾರು ಪಡೆಯುವ ಪ್ರಯತ್ನ.

896
00:49:43,130 --> 00:49:44,250
ನೀವು ಮಧ್ಯಮ ಹೋಗಿ.

897
00:49:44,250 --> 00:49:47,130
ಸಂಖ್ಯೆಗಳನ್ನು ವೇಳೆ ಮತ್ತು ನಂತರ ನೀವು ಪರಿಶೀಲಿಸಿ
ಎಡ ಮತ್ತು ಬಲ.

898
00:49:47,130 --> 00:49:49,650
>> ತದನಂತರ ನೀವು ಸಂಖ್ಯೆ ಕಂಡುಹಿಡಿಯಲು ವೇಳೆ
ಎಡ ಮೇಲೆ ಹೋಗಿ, ಅದೇ ಇಲ್ಲಿದೆ

899
00:49:49,650 --> 00:49:53,340
ಮತ್ತೆ ಹುಡುಕಾಟ ಮಾಡುವ ವಿಷಯ ಆದರೆ
ಪಟ್ಟಿಯ ಎಡ.

900
00:49:53,340 --> 00:49:57,350
ಅದು ಧ್ವನಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಆ ನ
ಹಾಗೆ ಇದು ಪುನರಾವರ್ತಿತ ಇಲ್ಲಿದೆ.

901
00:49:57,350 --> 00:50:01,870
ನೀವು ಹುಡುಗರಿಗೆ ಪುನರಾವರ್ತಿತ ಹೊಂದಿವೆ ಏಕೆ ಆ ನ
ವಿಲೀನ ರೀತಿಯ ಪರಿಹಾರ.

902
00:50:01,870 --> 00:50:04,270
>> ಸರಿ, ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ.

903
00:50:04,270 --> 00:50:07,280
ಇದರಿಂದ ನಾನು ಆಯ್ಕೆ ಬಯಸುವ ಹೇಳಲು ಅವಕಾಶ
1 ನಿಂದ n ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳು.

904
00:50:07,280 --> 00:50:13,790
ನಾನು ಅರ್ಥ ಎಂದು ಎನ್ ಭಾರತ
ಸಂಖ್ಯೆ n + n ಮೈನಸ್ 1 1 ಬಿಟ್ಟಿದ್ದು.

905
00:50:13,790 --> 00:50:17,810
ಆದರೆ, ನಾನು N ಮೈನಸ್ 1 ನೋಡಿದರೆ ಜೊತೆಗೆ
ಎನ್ ಮೈನಸ್ 2 + 1, ಅದೇ ಇಲ್ಲಿದೆ

906
00:50:17,810 --> 00:50:20,680
ಕೂಡಿಸಿ ಸಂಖ್ಯೆಗಳಾಗಿ ವಿಷಯ
ಗೆ N ಮೈನಸ್ 1 ಅಪ್.

907
00:50:20,680 --> 00:50:25,890
ಹಾಗಾಗಿ ಸಮಾನ ಮೊತ್ತ ಮೊತ್ತ ಹೇಳಬಹುದು
ಎನ್ ಮೈನಸ್ 1 ಎನ್ ಪ್ಲಸ್ ಮೊತ್ತಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ.

908
00:50:25,890 --> 00:50:28,010
ಎಂದು ಅರ್ಥ ಡಸ್?

909
00:50:28,010 --> 00:50:32,630
>> ಮತ್ತು ನಾನು ಯಾವುದೋ ಹೊಂದಿರುತ್ತದೆ
ಎಂದು ಇದು, ಮೂಲ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆ

910
00:50:32,630 --> 00:50:37,440
ಅಪ್ ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವು
ಸೊನ್ನೆಯಿಂದ ಎಂದು.

911
00:50:37,440 --> 00:50:42,770
ಆದ್ದರಿಂದ ತಕ್ಷಣ ನಾನು ಸಂಖ್ಯೆ ಸಿಗುತ್ತದೆಯೋ
ಶೂನ್ಯ, ನಾನು ಎಣಿಸುವ ನಿಲ್ಲಿಸಲು.

912
00:50:42,770 --> 00:50:45,330
ಎಂದು ಅರ್ಥ ಡಸ್?

913
00:50:45,330 --> 00:50:48,120
>> ಇಲ್ಲಿ ಹೇಗೆ ಒಂದು ಉದಾಹರಣೆ
ನಾನು ಬಳಸಿಕೊಂಡು.

914
00:50:48,120 --> 00:50:49,860
ಹಾಗಾಗಿ ಕೆಲವು ಈ ಫಂಕ್ಷನ್.

915
00:50:49,860 --> 00:50:51,700
ಆ ಒಂದು ಪೂರ್ಣಸಂಖ್ಯೆ n ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

916
00:50:51,700 --> 00:50:56,300
N ವೇಳೆ ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾನು ಮೊದಲ ಪರಿಶೀಲಿಸಿ
ಕಡಿಮೆ ಅಥವಾ ಶೂನ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ.

917
00:50:56,300 --> 00:51:00,310
ಆದ್ದರಿಂದ, ಸೊನ್ನೆಗೆ ಕಡಿಮೆ ಅಥವಾ ಸಮ ಇದ್ದರೆ ನಾನು
ನಮ್ಮ ಮೂಲ ಸಂದರ್ಭದಲ್ಲಿ ಇದು, ಶೂನ್ಯ.

918
00:51:00,310 --> 00:51:05,690
ಇಲ್ಲವಾದರೆ, ನಾನು ಮರಳಬಹುದು ಎನ್ ಪ್ಲಸ್
ಸಂಖ್ಯೆಗಳನ್ನು ಮೊತ್ತದಿಂದ

919
00:51:05,690 --> 00:51:07,190
ಎನ್ ಮೈನಸ್ ಒಂದು ಒಂದು.

920
00:51:07,190 --> 00:51:09,360
ಅರ್ಥ?

921
00:51:09,360 --> 00:51:10,100
ಸರಿ.

922
00:51:10,100 --> 00:51:11,610
>> ಇಲ್ಲಿ ಇದು ತೋರುತ್ತಿದೆ ಇಲ್ಲಿದೆ.

923
00:51:11,610 --> 00:51:15,260
ನೀವು 2 ಸಮ ಮೊತ್ತ ಹೊಂದಿವೆ
2 ಪ್ಲಸ್ 1 ಮೊತ್ತ.

924
00:51:15,260 --> 00:51:18,930
ಮತ್ತು 1 ಕೆಲವು ಪ್ಲಸ್ 1 ಆಗಿದೆ
0 ಇದು 0 ಮೊತ್ತವು,.

925
00:51:18,930 --> 00:51:20,216
ಅರ್ಥ?

926
00:51:20,216 --> 00:51:25,342
ನಾವು ಸ್ಟಾಕ್ ನೋಡಲು ಆದ್ದರಿಂದ ನಿಮ್ಮ
ಪ್ರೋಗ್ರಾಂ, ಇದು ಕಾಣುತ್ತದೆ ಏನು.

927
00:51:25,342 --> 00:51:26,820
>> ಮೊದಲ, ನಾವು ಮುಖ್ಯ ಫಂಕ್ಷನ್.

928
00:51:26,820 --> 00:51:30,320
ನಂತರ ಮುಖ್ಯ ಕಾರ್ಯ
ಮೊತ್ತ 2 ಎಂಬ.

929
00:51:30,320 --> 00:51:36,690
ತದನಂತರ ಮೊತ್ತ 2 ಓಹ್, ಹೇಳಲು ಹೋಗುತ್ತದೆ, ಭಾರತ
2 2 ಮತ್ತು ಒಂದು ಮೊತ್ತಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ.

930
00:51:36,690 --> 00:51:39,460
ಹಾಗಾಗಿ ಸ್ಟಾಕ್ 1 ಮೊತ್ತ ಸೇರಿಸಿ.

931
00:51:39,460 --> 00:51:43,860
ಮತ್ತು 1 ಮೊತ್ತ ಮೊತ್ತ ಕರೆಯಲು ಹೋಗುತ್ತದೆ
0, ಇದು ಸಹ ಸೇರಿಸಬಹುದು ಹೋಗುತ್ತದೆ

932
00:51:43,860 --> 00:51:44,630
ಸ್ಟಾಕ್.

933
00:51:44,630 --> 00:51:49,240
ಮತ್ತು ಎಂದು ಈ ಬಿಡಿಗಳ ನಂತರ ಪ್ರತಿ
ಪರಸ್ಪರ ಮೇಲೆ ಹಿಂದಿರುಗಿಸಬೇಕೆಂದು

934
00:51:49,240 --> 00:51:52,020
ಇತರೆ ಆಟಗಳಾಗಿದ್ದವು ಮುಂದುವರಿಸುವುದಕ್ಕೆ ಮೊದಲು.

935
00:51:52,020 --> 00:51:56,240
>> ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ಇಲ್ಲಿ, 0 ಮೊತ್ತವು,
ಮೊದಲ, 0 ಮರಳಲು ಹೋಗುತ್ತದೆ.

936
00:51:56,240 --> 00:51:58,320
ತದನಂತರ 1 ಮೊತ್ತ ಆಯ್ಕೆ.

937
00:51:58,320 --> 00:52:00,850
ನಂತರ 1 ಮೊತ್ತವು ಹೋಗುತ್ತದೆ
2 ಒಟ್ಟಾರೆಯಾಗಿ 1 ಮರಳಲು.

938
00:52:00,850 --> 00:52:03,900
ಮತ್ತು ಅಂತಿಮವಾಗಿ, 2 ಮೊತ್ತ ಹೋಗುತ್ತದೆ
ಮುಖ್ಯ 3 ಮರಳಲು.

939
00:52:03,900 --> 00:52:05,320
ಎಂದು ಅರ್ಥ ಡಸ್?

940
00:52:05,320 --> 00:52:09,496
>> ಇದು ಹೇಗೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಜವಾಗಿಯೂ ಪ್ರಮುಖ
ಸ್ಟಾಕ್ ಕೆಲಸ ಮತ್ತು ಪ್ರಯತ್ನಿಸಿ ಇದೆ

941
00:52:09,496 --> 00:52:11,980
ಇದು ಸಮಂಜಸವೇ ನೋಡಲು.

942
00:52:11,980 --> 00:52:13,260
ಸರಿ, ಆದ್ದರಿಂದ ವಿಂಗಡಿಸುವ.

943
00:52:13,260 --> 00:52:16,170
ಹಾಗಿರುವಾಗ, ಪ್ರಮುಖ ಬೇರ್ಪಡಿಸುವ ಇದೆ
ಎಲ್ಲಾ ಮೊದಲ?

944
00:52:16,170 --> 00:52:18,260
ಏಕೆ ನಾವು ಬೇಕು?

945
00:52:18,260 --> 00:52:20,310
ಯಾರಾದರೂ?

946
00:52:20,310 --> 00:52:20,695
ನನಗೆ ಉದಾಹರಣೆ ನೀಡಿ?

947
00:52:20,695 --> 00:52:21,040
ಹೌದು?

948
00:52:21,040 --> 00:52:22,968
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

949
00:52:22,968 --> 00:52:24,700
>> LUCAS: ಸರಿ, ಹೌದು.

950
00:52:24,700 --> 00:52:26,090
ಆದ್ದರಿಂದ ನೀವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹುಡುಕಬಹುದು.

951
00:52:26,090 --> 00:52:28,580
ಒಂದು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ.

952
00:52:28,580 --> 00:52:32,462
ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ನಾವು ಸಾಕಷ್ಟು ಆಫ್ ಹೊಂದಿವೆ
ವಿಷಯಗಳನ್ನು, ವಾಸ್ತವವಾಗಿ, ನಮ್ಮ ಜೀವನ ಎಂದು

953
00:52:32,462 --> 00:52:32,920
ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ.

954
00:52:32,920 --> 00:52:34,830
ಉದಾಹರಣೆಗೆ, ನಿಘಂಟುಗಳು.

955
00:52:34,830 --> 00:52:39,210
>> ಇದು ಎಲ್ಲಾ ಹೊಂದಿವೆ ಬಹಳ ಮುಖ್ಯ
ಸಲುವಾಗಿ ರೀತಿಯ ಪದಗಳನ್ನು ನಾವು

956
00:52:39,210 --> 00:52:41,970
ಸುಲಭವಾಗಿ ಪ್ರವೇಶಿಸಬಹುದು.

957
00:52:41,970 --> 00:52:43,280
ಆದ್ದರಿಂದ ಅವನ ಹೇಳಿಕೆಯ ಇಲ್ಲಿದೆ.

958
00:52:43,280 --> 00:52:45,530
ನೀವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಹುಡುಕಬಹುದು.

959
00:52:45,530 --> 00:52:48,740
ಇದು ಒಂದು ಎಂದು ಎಂದು ಹೇಗೆ ಹಾರ್ಡ್ ಥಿಂಕ್
ಪದಗಳನ್ನು ಇದರಲ್ಲಿ ನಿಘಂಟು

960
00:52:48,740 --> 00:52:49,500
ಯಾದೃಚ್ಛಿಕ ಸಲುವಾಗಿ.

961
00:52:49,500 --> 00:52:53,120
ನೀವು, ಬಹುಮಟ್ಟಿಗೆ, ನೋಡಲು ಹೊಂದಿವೆ ಮಾಡುತ್ತೇವೆ
ಪ್ರತಿಯೊಂದು ಪದವು ನೀವು ಹೇಗೆ ರವರೆಗೆ

962
00:52:53,120 --> 00:52:54,720
ನೀವು ಹುಡುಕುತ್ತಿರುವ ಪದ.

963
00:52:54,720 --> 00:52:58,710
>> ನೀವು ಫೇಸ್ಬುಕ್ ಬಳಸುತ್ತಿದ್ದರೆ, ಯಾವಾಗ
ನಿಮ್ಮ ಸ್ನೇಹಿತರು ಹುಡುಕುತ್ತಿರುವ, ನೀವು

964
00:52:58,710 --> 00:53:03,540
ಫೇಸ್ಬುಕ್ ಅಳವಡಿಸಿರುವ ನೋಡಲು ಹೋಗುವ ನಿಮ್ಮ
ಹತ್ತಿರ ಸ್ನೇಹಿತ ಪದಗಳಿಗಿಂತ ಮೇಲೆ ಇಲ್ಲಿದೆ

965
00:53:03,540 --> 00:53:05,470
ನೀವು ಹೆಚ್ಚು ಮಾತನಾಡಲು ಎಂದು.

966
00:53:05,470 --> 00:53:08,080
ನೀವು ಕೆಳಗೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ
ನಿಮ್ಮ ಸ್ನೇಹಿತರ ಪಟ್ಟಿಯಲ್ಲಿ, ನೀವು ನೋಡಲು ನೀನು

967
00:53:08,080 --> 00:53:11,250
ನೀವು ಬಹುಶಃ ಸಹ ಬಾರದ ಜನರು
ನೀವು ಸ್ನೇಹಿತರು ಎಂದು ನೆನಪಿಡಿ.

968
00:53:11,250 --> 00:53:14,590
ಮತ್ತು ಫೇಸ್ಬುಕ್ ರೀತಿಯ ಏಕೆಂದರೆ ಇಲ್ಲಿದೆ
ಹೇಗೆ ಆಧರಿಸಿ ನಿಮ್ಮ ಸ್ನೇಹಿತರು

969
00:53:14,590 --> 00:53:16,472
ನೀವು ಮಾಡುವುದು ಮುಚ್ಚಿ.

970
00:53:16,472 --> 00:53:17,930
>> ಆದ್ದರಿಂದ ಡೇಟಾ ಸಂಘಟಿಸುವ.

971
00:53:17,930 --> 00:53:18,450
ಅಲ್ಲದೆ ಪೋಕ್ಮನ್.

972
00:53:18,450 --> 00:53:21,400
ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲಾ Pokemons ನೋಡಿ
ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

973
00:53:21,400 --> 00:53:27,210
ಮತ್ತು ಸುಲಭ ರೀತಿಯಲ್ಲಿ
ಡೇಟಾ ಪ್ರವೇಶಿಸುವ ರೀತಿಯಲ್ಲಿ.

974
00:53:27,210 --> 00:53:29,050
>> ಪ್ರೇಕ್ಷಕರು: ಪೋಕ್ಮನ್ ಪ್ರವೇಶಿಸುವುದು.

975
00:53:29,050 --> 00:53:29,890
>> LUCAS: ಹೌದು.

976
00:53:29,890 --> 00:53:32,395
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

977
00:53:32,395 --> 00:53:33,460
>> LUCAS: ಹೌದು.

978
00:53:33,460 --> 00:53:35,140
ಸರಿ, ಆದ್ದರಿಂದ ಆಯ್ಕೆ ರೀತಿಯ.

979
00:53:35,140 --> 00:53:41,610
ಆಯ್ಕೆ ರೀತಿಯ ಆಯ್ಕೆ ನಡೆಯುತ್ತಿದೆ
ಒಂದು ಪಟ್ಟಿಯ ಚಿಕ್ಕ ಆಯ್ದ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿ

980
00:53:41,610 --> 00:53:43,300
ಪ್ರತಿ ಪುನರಾವರ್ತನೆ ಸಮಯ.

981
00:53:43,300 --> 00:53:46,800
ಅದನ್ನು ನೀವು ಮಾಡುವ ತೆರನಾದ ರೀತಿಯಲ್ಲಿ
ನಿಮ್ಮ ತಲೆಯಲ್ಲಿ ನೀವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

982
00:53:46,800 --> 00:53:48,430
ಕಡೆ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸಲು.

983
00:53:48,430 --> 00:53:51,990
>> ಮೂಲತಃ, ನೀವು ಎಲ್ಲಾ ನೀವು ನೋಡಲು ಆಗಿದೆ
ಚಿಕ್ಕ ಸಂಖ್ಯೆಯ.

984
00:53:51,990 --> 00:53:54,280
ನೀವು ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಇಟ್ಟಿದೆ.

985
00:53:54,280 --> 00:53:56,230
ತದನಂತರ ನೀವು ನೋಡಿ
ಮುಂದಿನ ಚಿಕ್ಕ ಸಂಖ್ಯೆ.

986
00:53:56,230 --> 00:54:00,080
ತದನಂತರ ನೀವು ನಡೆಸುವ
ಎಂದು ಹೀಗೆ.

987
00:54:00,080 --> 00:54:04,600
>> ಆದ್ದರಿಂದ ಆಯ್ಕೆ ರೀತಿಯ ನೀವು ಮೂಲತಃ
ಪ್ರತಿ ಬಾರಿ ಸಣ್ಣ ಆಯ್ಕೆ

988
00:54:04,600 --> 00:54:05,750
ಆಯ್ದ ಮೌಲ್ಯವನ್ನು.

989
00:54:05,750 --> 00:54:10,840
ವಿಂಗಡಿಸುತ್ತದೆ ಕೊನೆಯಲ್ಲಿ ಹಾಕಿ
ಪಟ್ಟಿ ಭಾಗವಾಗಿ.

990
00:54:10,840 --> 00:54:12,370
ಮತ್ತು ಮಾಡಿಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ.

991
00:54:12,370 --> 00:54:15,890
ಇದರಿಂದ ಬೇಗನೆ ನೋಡೋಣ ಏನು
ಈ ತೋರುತ್ತಿದೆ.

992
00:54:15,890 --> 00:54:19,340
ಇಲ್ಲಿ ವಿಂಗಡಿಸುತ್ತದೆ
ಮತ್ತು ಆಯ್ದ ಪಟ್ಟಿ.

993
00:54:19,340 --> 00:54:23,350
>> ಪಟ್ಟಿಯ ವಿಂಗಡಿಸಲಾದ ಆದ್ದರಿಂದ,
ಆರಂಭದಲ್ಲಿ ಖಾಲಿ.

994
00:54:23,350 --> 00:54:26,760
ಮತ್ತು ನಂತರ ನಾನು ಆಯ್ಕೆ ಪಡೆಯಲಿದ್ದೇನೆ
2 ಇದು ಇಲ್ಲಿ ಚಿಕ್ಕ ಸಂಖ್ಯೆ,.

995
00:54:26,760 --> 00:54:30,650
ಹಾಗಾಗಿ ಸಂಖ್ಯೆ 2 ಮತ್ತು ನಾನು ಪುಟ್
ಪಟ್ಟಿ ಮುಂದೆ.

996
00:54:30,650 --> 00:54:34,910
ಮತ್ತು ನಂತರ ನಾನು ಮುಂದಿನ ಚಿಕ್ಕ ನೋಡಿ
3 ಇದು ಅಂಶ,.

997
00:54:34,910 --> 00:54:37,050
ಹಾಗಾಗಿ ಕೊನೆಯಲ್ಲಿ ಹೇಳಿದಂತೆ
ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು.

998
00:54:37,050 --> 00:54:38,140
ತದನಂತರ ನಾನು ಮಾಡಿಕೊಳ್ಳಬೇಕಾಗುತ್ತದೆ.

999
00:54:38,140 --> 00:54:40,040
ನಾನು 4 ಹುಡುಕಲು ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಹೇಳಿದಂತೆ.

1000
00:54:40,040 --> 00:54:41,360
5 ಹುಡುಕಿ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಹೇಳಿದಂತೆ.

1001
00:54:41,360 --> 00:54:44,830
>> ಮತ್ತು ಆ ಕಾಲದ ಹೇಗೆ ಎಲ್ಲಾ ನೋಡಲು
ನಾನು, ಅಂತ್ಯ ಹಾಕಿದರೆ ಹೇಳುವ ನಾನು

1002
00:54:44,830 --> 00:54:46,850
ಮೂಲತಃ, ಎರಡು ಮೌಲ್ಯಗಳನ್ನು ವಿನಿಮಯ.

1003
00:54:46,850 --> 00:54:48,100
ಸರಿ?

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
ನಂತರ ಕಳೆದ ಒಂದು, ನೀವು
ಒಂದು ಹೆಚ್ಚಿಗೆ ಘಟಕವನ್ನು ಹೊಂದಿರುತ್ತವೆ.

1006
00:54:52,825 --> 00:54:55,870
ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ.

1007
00:54:55,870 --> 00:54:57,800
>> ಸರಿ, ಆದ್ದರಿಂದ ಅಳವಡಿಕೆಯ ರೀತಿಯ.

1008
00:54:57,800 --> 00:55:03,180
ಅಳವಡಿಕೆಯ ರೀತಿಯ ನೀವು ಎಂದು ನೀನು
ಒಂದು ವಿಂಗಡಿಸಲಾದ ನಂತರ ಆ ವಿಷಯ ಮತ್ತು

1009
00:55:03,180 --> 00:55:04,690
ಒಂದು ಆಯ್ದ ಪಟ್ಟಿಯನ್ನು.

1010
00:55:04,690 --> 00:55:14,540
ಮಾತ್ರ ವಿಷಯ ಪ್ರತಿ ಬಾರಿ ಆ
ನೀವು ವಿಂಗಡಿಸಲಾದ ಒಂದು ಅಂಶ ಸೇರಿಸಲು ನೀವು

1011
00:55:14,540 --> 00:55:18,170
ಪಟ್ಟಿಯಲ್ಲಿ, ನೀವು ಅಂಶ ಪಿಕ್
ಆಯ್ದ ಪಟ್ಟಿಯನ್ನು ಮುಂದೆ.

1012
00:55:18,170 --> 00:55:20,880
ಮತ್ತು ನಂತರ ನೀವು ಏನು ಹೇಗೆ ನೀನು
ಸ್ಥಾನವನ್ನು ಇದು ಪ್ರತಿಗಳ ಇರಬೇಕು

1013
00:55:20,880 --> 00:55:22,300
ಪಟ್ಟಿ ಭಾಗವಾಗಿ.

1014
00:55:22,300 --> 00:55:25,840
>> ಈ ಆದ್ದರಿಂದ ಏನು ನೋಡೋಣ
ಈ ಹೆಚ್ಚಿನ ಅರ್ಥವಿಲ್ಲ.

1015
00:55:25,840 --> 00:55:29,360
ಆದ್ದರಿಂದ ಆರಂಭದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ನಾನು ಪ್ರಯತ್ನಿಸುವಾಗ ನಾನು
ಮೂರನೇ ಸೇರಿಸಲು

1016
00:55:29,360 --> 00:55:30,680
ಪಟ್ಟಿಯ ವಿಂಗಡಿಸಲಾದ ಭಾಗವನ್ನು.

1017
00:55:30,680 --> 00:55:31,800
ಆದ್ದರಿಂದ ಪಟ್ಟಿಯಲ್ಲಿ ಏನು ಹೊಂದಿಲ್ಲ.

1018
00:55:31,800 --> 00:55:34,160
ಆದ್ದರಿಂದ ನಾನು ಸಂಖ್ಯೆ 3 ಹಾಕಬಹುದು.

1019
00:55:34,160 --> 00:55:37,480
>> ಈಗ, ನಾನು ಸಂಖ್ಯೆ 5 ಸೇರಿಸಲು ಬಯಸುವ
ಪಟ್ಟಿಯ ವಿಂಗಡಿಸಲಾದ ಭಾಗವನ್ನು.

1020
00:55:37,480 --> 00:55:38,900
ಹಾಗಾಗಿ ಸಂಖ್ಯೆ 5 ನೋಡಲು.

1021
00:55:38,900 --> 00:55:40,450
ನಾನು 3 ಹೆಚ್ಚಾಗಿದೆ ಎಂದು ಗಮನಿಸುವುದಿಲ್ಲ.

1022
00:55:40,450 --> 00:55:41,980
ಹಾಗಾಗಿ ಇದು 3 ನಂತರ ಇರಬೇಕು ಎಂದು ತಿಳಿದಿದೆ.

1023
00:55:41,980 --> 00:55:44,100
ಹಾಗಾಗಿ 3 ಮತ್ತು 5 ಪುಟ್.

1024
00:55:44,100 --> 00:55:45,940
>> ನಂತರ ನಾನು ಸಂಖ್ಯೆ 2 ಸೇರಿಸಲು ಬಯಸುವ.

1025
00:55:45,940 --> 00:55:51,630
ನಾನು ಸಂಖ್ಯೆ 2 ವಾಸ್ತವವಾಗಿ ಗಮನಿಸಿ
ನಂತರ 3 ಮತ್ತು 5 ಎರಡೂ ಕಾಲ.

1026
00:55:51,630 --> 00:55:54,580
ನಾನು ವಾಸ್ತವವಾಗಿ ಎಲ್ಲಾ ಹಾಕಬೇಕು
ಪಟ್ಟಿ ಪ್ರಾರಂಭದಲ್ಲಿ ರೀತಿಯಲ್ಲಿ.

1027
00:55:54,580 --> 00:55:59,030
ಹಾಗಾಗಿ, ರೀತಿಯ, ಎಲ್ಲಾ ಸ್ಥಳಾಂತರಿಸಿ
ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಆದ್ದರಿಂದ ನಾನು ಅಂಶಗಳ

1028
00:55:59,030 --> 00:56:01,970
ಸಂಖ್ಯೆ 2 ಕೊಠಡಿ ಮಾಡಲು.

1029
00:56:01,970 --> 00:56:03,160
>> ಆಗ ನಾನು 6 ನೋಡಿ.

1030
00:56:03,160 --> 00:56:05,450
ನಾನು 5 ನಂತರ ಎಂದು ನೋಡಿ.

1031
00:56:05,450 --> 00:56:06,240
ಹಾಗಾಗಿ ಅಲ್ಲಿ ಇಟ್ಟಿದೆ.

1032
00:56:06,240 --> 00:56:07,965
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾನು ಸಂಖ್ಯೆ 4 ನೋಡಿದರೆ.

1033
00:56:07,965 --> 00:56:11,030
ನಾನು ಇದನ್ನು ಗಮನಕ್ಕೆ
3 ಮತ್ತು 5 ನಡುವೆ.

1034
00:56:11,030 --> 00:56:14,870
ತದನಂತರ ನಾನು ಪಕ್ಕಾ ಶಿಫ್ಟ್
ಎಲ್ಲಾ ಇತರ ಅಂಶಗಳು.

1035
00:56:14,870 --> 00:56:16,120
ಅರ್ಥ?

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> ಬಬಲ್ ವಿಂಗಡಿಸಿ.

1038
00:56:19,150 --> 00:56:25,730
ಬಬಲ್ ರೀತಿಯ ನೀವು ಯಾವ ಮೂಲಭೂತ
ಹೋಗುವ ನಾವು ಬಬಲ್ ಕರೆ do-- ಗೆ

1039
00:56:25,730 --> 00:56:30,113
ನೀವು ಪಟ್ಟಿಯಲ್ಲಿ ಅನುಸರಿಸುವ ರೀತಿಯ ಏಕೆಂದರೆ
ನಾನು ತೋರಿಸಲು ನಿಜವಾಗಿ ಉತ್ತಮ

1040
00:56:30,113 --> 00:56:32,300
ನೀವು ಈ ರೀತಿಯ

1041
00:56:32,300 --> 00:56:35,030
ಮತ್ತು ನೀವು ಹೋಲಿಸಲು ನೀನು
ಪಕ್ಕದ ಸಂಖ್ಯೆಗಳು.

1042
00:56:35,030 --> 00:56:38,410
ಮತ್ತು ನೀವು ವಿನಿಮಯ ನೀನು ತಮ್ಮ
ಸ್ಥಾನಗಳು ಅವರು ಇಲ್ಲದಿದ್ದರೆ

1043
00:56:38,410 --> 00:56:39,190
ಸರಿಯಾದ ಕ್ರಮದಲ್ಲಿ.

1044
00:56:39,190 --> 00:56:42,570
>> ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ಏನು ಹೋಗುತ್ತದೆ
ಇಲ್ಲಿ ಸಂಭವಿಸಿ, ಉದಾಹರಣೆಗೆ,

1045
00:56:42,570 --> 00:56:44,160
ನೀವು 8 ಮತ್ತು 6 ಹೊಂದಿವೆ.

1046
00:56:44,160 --> 00:56:47,270
ನೀವು ವಿಂಗಡಿಸಲಾದ ಸಲುವಾಗಿ ತಿನ್ನುವೆ ಗೊತ್ತಿಲ್ಲ
ವಾಸ್ತವವಾಗಿ ಬಲ 6 ಮತ್ತು 5, ಎಂದು?

1047
00:56:47,270 --> 00:56:49,540
ನೀವು ಆದೇಶಗಳನ್ನು ವಿನಿಮಯ ನೀನು.

1048
00:56:49,540 --> 00:56:51,370
ನಂತರ ನಾನು ಇಲ್ಲಿ 8 ಮತ್ತು 4 ನೋಡಿ.

1049
00:56:51,370 --> 00:56:52,250
ಮತ್ತು ಒಂದೇ ವಿಷಯವನ್ನು.

1050
00:56:52,250 --> 00:56:53,400
ನಾನು ಮತ್ತೆ ವಿನಿಮಯ.

1051
00:56:53,400 --> 00:56:55,070
ಮತ್ತು ಅಂತಿಮವಾಗಿ, 2 ಮತ್ತು 8.

1052
00:56:55,070 --> 00:56:56,670
ನಾನು ಅವುಗಳನ್ನು ವಿನಿಮಯ.

1053
00:56:56,670 --> 00:57:01,690
>> ಬಬಲ್ ವಿಂಗಡಿಸಿ ಏಕೆಂದರೆ ನಂತರ ಕರೆಯಲಾಗುತ್ತದೆ
ಈ ಪುನರಾವರ್ತನೆಗಳು ಪ್ರತಿ, ವಾಸ್ತವವಾಗಿ,

1054
00:57:01,690 --> 00:57:05,910
ಪಟ್ಟಿಯಲ್ಲಿ ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಎಲ್ಲಾ ಪಡೆಯುತ್ತದೆ
ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ರೀತಿಯಲ್ಲಿ.

1055
00:57:05,910 --> 00:57:06,940
ಎಂದು ಅರ್ಥ ಡಸ್?

1056
00:57:06,940 --> 00:57:11,880
ಇದು ವಿನಿಮಯ ಇಡುತ್ತದೆ ಏಕೆಂದರೆ
ಮತ್ತು ಬಲ ಅದನ್ನು ಚಲಿಸುವ.

1057
00:57:11,880 --> 00:57:14,440
>> ಸರಿ, ಆದ್ದರಿಂದ ಈ ಎರಡನೇ ಪುನರಾವರ್ತನೆ ಆಗಿದೆ.

1058
00:57:14,440 --> 00:57:17,200
ಇದು ಒಂದೇ ಎಂದು.

1059
00:57:17,200 --> 00:57:20,190
ನಾನು ಒಂದು ಸ್ವಾಪ್ ಮಾಡುತ್ತೇನೆ ಮತ್ತು
ನಂತರ ಕಳೆದ ಒಂದು.

1060
00:57:20,190 --> 00:57:23,290
ಯಾವುದೇ ಸ್ವಾಪ್ಸ್ ಇವೆ ನಾನು
ಮತ್ತು ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ.

1061
00:57:23,290 --> 00:57:27,460
ಬಬಲ್ ವಿಂಗಡಿಸಿ, ನಾವು ಮೂಲತಃ ಇರಿಸಿಕೊಳ್ಳಲು
ಪಟ್ಟಿಯನ್ನು ಹಾದುಹೋಗುವ ಮತ್ತು ವಿನಿಮಯ

1062
00:57:27,460 --> 00:57:32,310
ವಿಷಯಗಳನ್ನು ನಾನು ಕಾಣಲಿಲ್ಲ ಗಮನಕ್ಕೆ ರವರೆಗೆ
ಆ ಪುನರಾವರ್ತನೆ ಮಾಡುವ ಯಾವುದೇ ವಿನಿಮಯ, ಇದು

1063
00:57:32,310 --> 00:57:34,270
ಪಟ್ಟಿಯನ್ನು ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ಎಂದರ್ಥ.

1064
00:57:34,270 --> 00:57:35,520
ಅರ್ಥ?

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> ನ ಸ್ವಲ್ಪ ಮಾತನಾಡೋಣ
ಸಮಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಗ್ಗೆ.

1067
00:57:40,870 --> 00:57:45,165
ಆದ್ದರಿಂದ ನೀವು ಹುಡುಗರಿಗೆ ಬಿಗ್ ನೆನಪಿಸುತ್ತಾರೆ
ಓ, ಒಮೆಗಾ, ಮತ್ತು ಥೀಟಾ?

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
ಹೌದು?

1070
00:57:50,990 --> 00:57:53,070
ಸರಿ, ದೊಡ್ಡ ಒ ಎಲ್ಲಾ ಮೊದಲ, ಏನು?

1071
00:57:53,070 --> 00:57:54,315
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1072
00:57:54,315 --> 00:57:59,070
>> LUCAS: ಹೌದು, ಇದು ಒಂದು ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ
ಅದನ್ನು ಅಂದರೆ ರನ್ಟೈಮ್,

1073
00:57:59,070 --> 00:58:03,470
ಎಷ್ಟು ನೀವು ಪ್ರೋಗ್ರಾಂ ನಿರೀಕ್ಷಿಸಬಹುದು
ರನ್ ತೆಗೆದುಕೊಳ್ಳುವ.

1074
00:58:03,470 --> 00:58:04,910
ಲೈಕ್, ವಿಷಯದಲ್ಲಿ ಇಲ್ಲಿದೆ

1075
00:58:04,910 --> 00:58:06,660
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಎನ್ ರಲ್ಲಿ.

1076
00:58:06,660 --> 00:58:09,150
ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಪಟ್ಟಿ.

1077
00:58:09,150 --> 00:58:12,520
ಲೈಕ್, ಕೆಟ್ಟ ಸಾಧ್ಯ ಸಂದರ್ಭದಲ್ಲಿ.

1078
00:58:12,520 --> 00:58:17,100
>> ಬಬಲ್ ವಿಂಗಡಿಸಿ ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ,
ನಾವು N ಚೌಕದ ಬಿಗ್ ಓ ಹೊಂದಿವೆ.

1079
00:58:17,100 --> 00:58:20,580
ಏಕೆ ನಾವು ಹೊಂದಿಲ್ಲ?

1080
00:58:20,580 --> 00:58:24,716
ಏಕೆ ಬಬಲ್ ದೊಡ್ಡ ಒ ಎನ್ ಚದರ ತೆರನಾದ?

1081
00:58:24,716 --> 00:58:27,614
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1082
00:58:27,614 --> 00:58:35,670
>> LUCAS: ಹೌದು, ಆದ್ದರಿಂದ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಇರುತ್ತದೆ
ನಾನು ಎನ್ ಪುನರಾವರ್ತನೆಗಳು ಮಾಡಲು ಸಾಧ್ಯವಿದೆ.

1083
00:58:35,670 --> 00:58:39,260
ಆದ್ದರಿಂದ ಪುನರಾವರ್ತನೆಗಳು ಪ್ರತಿ ಹೋಗುತ್ತದೆ
ಕೊನೆಗೆ ದೊಡ್ಡ ಅಂಶ ತರಲು

1084
00:58:39,260 --> 00:58:40,290
ಪಟ್ಟಿಯ.

1085
00:58:40,290 --> 00:58:44,230
ಆದ್ದರಿಂದ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ನಾನು ಹೊಂದಿವೆ
ವಿಷಯ N ಬಾರಿ ಮಾಡಲು.

1086
00:58:44,230 --> 00:58:48,550
ಆ ಕಾಲದಲ್ಲಿ ಪ್ರತಿಯೊಂದು, ನಾನು ಹೊಂದಿವೆ
ನಾನು ಹೋಲಿಸಿ ಏಕೆಂದರೆ ಎನ್ ವಿನಿಮಯ ಮಾಡಲು

1087
00:58:48,550 --> 00:58:49,870
ಪ್ರತಿ ಎರಡು ಅಂಶಗಳು.

1088
00:58:49,870 --> 00:58:53,730
ವರ್ಗ n 'ಏಕೆ ಆ ನ
ಇದು N ಬಾರಿ ಏಕೆಂದರೆ.

1089
00:58:53,730 --> 00:59:00,120
>> ನಂತರ, ಆಯ್ಕೆ ರೀತಿಯ ಸಹ ಎನ್ ಚದರ
ಏಕೆಂದರೆ, ಪ್ರತಿ ಪುನರಾವರ್ತನೆ ಫಾರ್, ನಾನು ಹೊಂದಿವೆ

1090
00:59:00,120 --> 00:59:02,650
ಪ್ರತಿಯೊಂದು ಅಂಶ ನೋಡಲು
ಪಟ್ಟಿಯಲ್ಲಿ.

1091
00:59:02,650 --> 00:59:04,980
ನಂತರ, ಚಿಕ್ಕ ಹೇಗೆ
ಇದು ನಾನು ಎಂದು ಅರ್ಥ

1092
00:59:04,980 --> 00:59:06,130
ಎನ್ ಅಂಶಗಳ ಮೂಲಕ ನೋಡೋಣ.

1093
00:59:06,130 --> 00:59:11,750
ಮತ್ತು ನಾನು ಆ N ಬಾರಿ ಮಾಡಬೇಕು
ನಾನು ಎಲ್ಲಾ N ಅಂಶಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕು.

1094
00:59:11,750 --> 00:59:18,273
>> ಒಂದು ಅಳವಡಿಕೆಯ ರೀತಿಯ ಸಹ ಎನ್ ಚದರ
ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ ಏಕೆಂದರೆ

1095
00:59:18,273 --> 00:59:20,950
, ಎಂದು, ನಾನು ಸೇರಿಸಲು ಹೊಂದಿವೆ
n ಸಂಖ್ಯೆಗಳು, ಬಲ?

1096
00:59:20,950 --> 00:59:22,765
ಆದ್ದರಿಂದ ನಾನು ಈಗಾಗಲೇ ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ತಿಳಿದಿದೆ
ಎನ್ ಪುನರಾವರ್ತನೆಗಳು ಹೊಂದಲು.

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
ಆದರೆ ನಾನು ಆ ಸಂಖ್ಯೆಗಳನ್ನು ಪ್ರತಿ, ವೇಳೆ
ಸಂಖ್ಯೆಗಳ ಎಲ್ಲಾ ನೋಡಲು

1099
00:59:29,840 --> 00:59:34,380
ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಮತ್ತು ಇದು ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಪುಟ್
ಮುಂದೆ, ಆ N ಚದರ ಇರುತ್ತದೆ

1100
00:59:34,380 --> 00:59:36,230
ಇದು N ಬಾರಿ ಮತ್ತೆ ಏಕೆಂದರೆ.

1101
00:59:36,230 --> 00:59:38,280
ಅರ್ಥ?

1102
00:59:38,280 --> 00:59:41,512
ಏನು ಒಮೆಗಾ ಬಗ್ಗೆ?

1103
00:59:41,512 --> 00:59:42,886
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1104
00:59:42,886 --> 00:59:44,620
>> LUCAS: ಇದು ಉತ್ತಮ ನಿದರ್ಶನ ಇಲ್ಲಿದೆ.

1105
00:59:44,620 --> 00:59:48,810
ಆದ್ದರಿಂದ ಬಾರಿ ಸಾಕಷ್ಟು ಸ್ಥಾನ, ಹೀಗಿದೆ
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭಗಳಲ್ಲಿ ಹೊಂದಿದೆ, ವಿಂಗಡಿಸುವ

1106
00:59:48,810 --> 00:59:50,660
ಪಟ್ಟಿ ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ.

1107
00:59:50,660 --> 00:59:52,670
ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಇಲ್ಲ
ಏನು ಮಾಡಲು.

1108
00:59:52,670 --> 00:59:56,290
ಬಬಲ್ ವಿಂಗಡಿಸಿ ಉತ್ತಮ ಹೊಂದಿದೆ
n ನ ನಿದರ್ಶನ.

1109
00:59:56,290 --> 00:59:58,820
ನೀವು ಹುಡುಗರಿಗೆ ಏಕೆ ಗೊತ್ತಾ?

1110
00:59:58,820 --> 01:00:00,620
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1111
01:00:00,620 --> 01:00:05,640
>> LUCAS: ಹೌದು, ನೀವು ಟ್ರ್ಯಾಕ್
ಡೇಟಾ ಪಡಿತರ ಯಾವುದೇ ವಿನಿಮಯ ಹೊಂದಿದ್ದರು ಎಂಬುದನ್ನು

1112
01:00:05,640 --> 01:00:10,533
ನೀವು ಏನಾದರೂ ಇಲ್ಲದಿದ್ದರೆ, ಸೆಟ್ ರೀತಿಯ
ಒಂದು ಪುನರಾವರ್ತನೆ ವೇಳೆ, ಇಲ್ಲದಿದ್ದರೆ ನಿಜವಾದ

1113
01:00:10,533 --> 01:00:15,140
ಪಟ್ಟಿಯನ್ನು ಈಗಾಗಲೇ, ಮೂಲತಃ, ವಿಂಗಡಿಸಲ್ಪಡುತ್ತದೆ
ತೀರುತ್ತದೆ ವಿಶೇಷವೇನು ನಾನು ಪಡೆಯಲಿದ್ದೇನೆ ಆಗಿದೆ

1114
01:00:15,140 --> 01:00:17,890
ಪ್ರತಿ ಎರಡು ಬದಲಾಯಿಸಿ ಪ್ರಯತ್ನಿಸಿ
ಪಕ್ಕದ ಅಂಶಗಳನ್ನು.

1115
01:00:17,890 --> 01:00:19,920
ನಾನು ನೋಡಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಯಾವುದೇ ಸ್ವಾಪ್ಸ್ ಇವೆ.

1116
01:00:19,920 --> 01:00:21,230
ಮತ್ತು ನಾನು ತಕ್ಷಣ ಮರಳಿ.

1117
01:00:21,230 --> 01:00:24,240
>> ಆದ್ದರಿಂದ ನಾನು ಎಂದು ಅರ್ಥ
ಪಟ್ಟಿ ಒಂದು ಬಾರಿ ಮೂಲಕ ಹೋಗಿ.

1118
01:00:24,240 --> 01:00:28,990
ನಾನು ನೋಡಲು ಏಕೆಂದರೆ ಆದ್ದರಿಂದ n '
ಎನ್ ಅಂಶಗಳನ್ನು.

1119
01:00:28,990 --> 01:00:30,930
ಏಕೆ ಆಯ್ಕೆ ರೀತಿಯ N ಚದರ?

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> ಹೌದು, ಪಟ್ಟಿ ವಿಂಗಡಿಸಲ್ಪಡುತ್ತದೆ ಸಹ,
ಆಯ್ಕೆ ರೀತಿಯ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ, ನಾನು

1122
01:00:45,520 --> 01:00:47,590
ಕನಿಷ್ಠ ಅಂಶ ಆಯ್ಕೆ ಮಾಡಬೇಕು.

1123
01:00:47,590 --> 01:00:49,980
ಆದ್ದರಿಂದ ನಾನು ನೋಡಲು ಔಟ್ ಎಂದು ಅರ್ಥ
ಆಯ್ದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು

1124
01:00:49,980 --> 01:00:53,350
ಪಟ್ಟಿ ಮತ್ತು ಕನಿಷ್ಠ ಪಡೆಯುವ
ಪ್ರತಿ ಪುನರಾವರ್ತನೆ ಫಾರ್.

1125
01:00:53,350 --> 01:00:54,600
ಎಂದು ಅರ್ಥ ಡಸ್?

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> ಮತ್ತು ಅಳವಡಿಕೆ ಕತ್ತಿ ಏಕೆಂದರೆ ಎನ್
ನಾನು ಸೇರಿಸಲು ಪ್ರಯತ್ನ ನಾನು ಆ ಸಂದರ್ಭದಲ್ಲಿ

1128
01:01:04,690 --> 01:01:09,320
ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಸಂಖ್ಯೆಗಳ ಎಲ್ಲಾ, ನಾನು
ಅವುಗಳನ್ನು ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಿ, ಅವರು ನೋಡಿ

1129
01:01:09,320 --> 01:01:10,510
ಬಲ ಸ್ಥಾನದಲ್ಲಿರುತ್ತಾರೆ.

1130
01:01:10,510 --> 01:01:15,120
ನಾನು ಎಲ್ಲಾ ಇತರ ಪರಿಶೀಲಿಸಿ ಹೋಗಲು ಹೊಂದಿಲ್ಲ
ಆಯ್ದ ಪಟ್ಟಿಯನ್ನು ಸಂಖ್ಯೆಗಳನ್ನು.

1131
01:01:15,120 --> 01:01:17,170
ಇದು ಎನ್ ಇರುತ್ತದೆ ಏಕೆ ಆ ನ.

1132
01:01:17,170 --> 01:01:19,480
ಅರ್ಥ?

1133
01:01:19,480 --> 01:01:21,035
ಮತ್ತು ಥೀಟಾ ಏನು?

1134
01:01:21,035 --> 01:01:23,410
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1135
01:01:23,410 --> 01:01:24,380
>> LUCAS: ಏನು, ಕ್ಷಮಿಸಿ?

1136
01:01:24,380 --> 01:01:24,960
ಮತ್ತೆ ಹೇಳುತ್ತಾರೆ.

1137
01:01:24,960 --> 01:01:25,666
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1138
01:01:25,666 --> 01:01:26,490
>> LUCAS: ನಿಖರವಾಗಿ.

1139
01:01:26,490 --> 01:01:31,280
ಆದ್ದರಿಂದ ನೀವು ಕೇವಲ ಆಯ್ಕೆ ನೋಡಬಹುದು
ವಿಲೀನಗೊಳಿಸಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ರೀತಿಯ thetas ಹೊಂದಿವೆ.

1140
01:01:31,280 --> 01:01:39,920
ನೀವು ಮಾತ್ರ ಥೀಟಾ ಏಕೆಂದರೆ ಮತ್ತು ಇಲ್ಲಿದೆ
ದೊಡ್ಡ ಒ ಮತ್ತು ಒಮೆಗಾ ಎರಡೂ ಒಂದೇ ವೇಳೆ.

1141
01:01:39,920 --> 01:01:41,520
ಸರಿ.

1142
01:01:41,520 --> 01:01:44,210
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಲಾಗ್ N ರಲ್ಲಿ ವಿಲೀನ ರೀತಿಯ.

1143
01:01:44,210 --> 01:01:48,910
>> ಡಾನ್ ಹೇಳಿಕೆಯ ನಂತರ, ವಿಲೀನವನ್ನು
ರೀತಿಯ ರೀತಿಯಲ್ಲಿ ಹಾಗೆ

1144
01:01:48,910 --> 01:01:50,320
ನೀವು ಬೈನರಿ ಸರ್ಚ್ ಮಾಡಲು.

1145
01:01:50,320 --> 01:01:53,530
ಆದ್ದರಿಂದ ನೀವು ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು.

1146
01:01:53,530 --> 01:01:55,170
ಮತ್ತು ನೀವು ಅರ್ಧಕ್ಕೇ ನೀನು.

1147
01:01:55,170 --> 01:02:00,580
ನೀವು ಅವುಗಳನ್ನು ಕತ್ತರಿಸಿ
ಸಣ್ಣ ಅರ್ಥ.

1148
01:02:00,580 --> 01:02:01,730
ನೀವು ಅವುಗಳನ್ನು ವಿಲೀನಗೊಳ್ಳಲು.

1149
01:02:01,730 --> 01:02:02,960
ನೀವು ಹುಡುಗರಿಗೆ ಬಲ, ನೆನಪು

1150
01:02:02,960 --> 01:02:04,960
ಸರಿ, ಅವರು ಹೇಳಿಕೆಯ.

1151
01:02:04,960 --> 01:02:08,330
>> ಸರಿ, ಪಾಯಿಂಟರ್ಸ್.

1152
01:02:08,330 --> 01:02:11,078
ಆದ್ದರಿಂದ ಒಂದು ಪಾಯಿಂಟರ್ ಏನು?

1153
01:02:11,078 --> 01:02:12,050
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS: ಒಂದು ವಿಳಾಸ.

1155
01:02:12,820 --> 01:02:13,720
ಸರಿ.

1156
01:02:13,720 --> 01:02:18,530
ನಾನು ಡೇವಿಡ್ ಒಂದು ಗುಂಪನ್ನು ತೋರಿಸುವ ಗೊತ್ತು
Binky ವೀಡಿಯೊಗಳನ್ನು ಮತ್ತು ವಿಷಯಗಳನ್ನು ಸೂಚಿಸುವ

1157
01:02:18,530 --> 01:02:19,080
ಪರಸ್ಪರ.

1158
01:02:19,080 --> 01:02:22,960
ಆದರೆ ನಾನು ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಯೋಚಿಸಲು ನಾನು ಇಷ್ಟಪಡುತ್ತೇನೆ
ಕೇವಲ ಒಂದು ವಿಳಾಸಕ್ಕೆ.

1159
01:02:22,960 --> 01:02:26,110
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ವೇರಿಯೇಬಲ್ ನ
ವಿಳಾಸಕ್ಕೆ ಶೇಖರಿಸಿಡಲು.

1160
01:02:26,110 --> 01:02:31,940
>> ಆದ್ದರಿಂದ ಕೇವಲ ಈ ವಿಶೇಷ ವೇರಿಯಬಲ್
ಆ ನಾಲ್ಕು ಬೈಟ್ಗಳು ಉದ್ದವಾಗಿದೆ.

1161
01:02:31,940 --> 01:02:36,550
ಏನು ಎಂದು ಪಾಯಿಂಟರ್ ನೆನಪಿಡಿ
ನಮ್ಮ 32 ಬಿಟ್ ಬಹುಕಾಲ ಯಾವಾಗಲೂ ನಾಲ್ಕು ಬೈಟ್ಗಳು

1162
01:02:36,550 --> 01:02:39,370
ಯಂತ್ರ ಪ್ರಕರಣ ಆದ್ದರಿಂದ
ಉಪಕರಣಗಳಲ್ಲಿರುವ.

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
ಮತ್ತು ಇದು ಕೇವಲ ಸ್ಥಳ ಹೊಂದಿದೆ
ಇದು ಒಂದು ವೇರಿಯಬಲ್ ಒಳಗೆ.

1165
01:02:47,050 --> 01:02:50,240
>> ಸರಿ, ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ಈ ಮೆಮೊರಿ ಇಲ್ಲ.

1166
01:02:50,240 --> 01:02:57,420
ಆದ್ದರಿಂದ ಮೆಮೊರಿ ಪ್ರತಿ ಬ್ಲಾಕ್ ವಾಸ್ತವವಾಗಿ ಹೊಂದಿದೆ ಒಂದು
ವಿಳಾಸ ಲೇಬಲ್,

1167
01:02:57,420 --> 01:02:58,890
slotty ಮೆಮೊರಿ.

1168
01:02:58,890 --> 01:03:02,370
ಆದ್ದರಿಂದ ನಾನು ಹೊಂದಬಹುದು ಎಂದು
ಒಂದು ಪಾಯಿಂಟರ್

1169
01:03:02,370 --> 01:03:03,380
ಈ ವಿಳಾಸಗಳು ಯಾವುದೇ.

1170
01:03:03,380 --> 01:03:09,930
ನಾವು ಪಾಯಿಂಟರ್ಸ್ ಬಳಸಿ ಕಾರಣವಾಗಿದೆ
ನಾನು ಸ್ಥಳ ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ ವೇಳೆ

1171
01:03:09,930 --> 01:03:12,300
ಒಂದು ನಿರ್ದಿಷ್ಟ ವೇರಿಯಬಲ್ ಒಂದು ನೆನಪಾಗಿ.

1172
01:03:12,300 --> 01:03:16,560
>> ನೀವು ಹುಡುಗರಿಗೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಆ ಒಂದು ಎಂದು
ನಾನು ಕಾರ್ಯ ಹೊಂದಿದ್ದರೆ ಸಂದರ್ಭಗಳಲ್ಲಿ

1173
01:03:16,560 --> 01:03:20,820
ನಾನು ಹೊಂದಿದ್ದರೆ ಬಯಸುವ
ರಿಯಲ್ಗಳನ್ನು ಫಾರ್ ಸ್ವಾಪ್, ನಾನು

1174
01:03:20,820 --> 01:03:22,110
ಒಂದು ಪಾಯಿಂಟರ್ ಕಳುಹಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

1175
01:03:22,110 --> 01:03:23,460
ವೇರಿಯಬಲ್.

1176
01:03:23,460 --> 01:03:25,200
ನೀವು ಹುಡುಗರಿಗೆ ನೆನಪಿದೆಯೇ?

1177
01:03:25,200 --> 01:03:26,450
ವ್ಯತ್ಯಾಸ ನಡುವೆ

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
ಹೆಸರು ಏನು?

1180
01:03:34,120 --> 01:03:36,010
ಮೌಲ್ಯ ಮತ್ತು ಕರೆದು ಕಾಲಿಂಗ್
ಉಲ್ಲೇಖ, ಬಲ?

1181
01:03:36,010 --> 01:03:36,840
>> ಸರಿ.

1182
01:03:36,840 --> 01:03:38,330
ಆದ್ದರಿಂದ ಮೌಲ್ಯ ಕರೆ.

1183
01:03:38,330 --> 01:03:43,570
ನೀವು ವೇರಿಯಬಲ್ ಕಳುಹಿಸಿದಾಗ
ನೀವು ಈ ಕೆಳಗಿನ ಕಳುಹಿಸಲು ನೀವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

1184
01:03:43,570 --> 01:03:45,610
ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಕಳುಹಿಸಲು ನೀವು
ವೇರಿಯಬಲ್ ಪ್ರತಿಯನ್ನು.

1185
01:03:45,610 --> 01:03:49,720
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ತಲೆಕೆಡಿಸಿಕೊಳ್ಳಲಿಲ್ಲ
ವಾಸ್ತವವಾಗಿ ಅದೇ ವೇರಿಯಬಲ್ ವೇಳೆ ಬಗ್ಗೆ

1186
01:03:49,720 --> 01:03:51,650
ಪ್ರತಿಯನ್ನು ಮಾಡುತ್ತದೆ.

1187
01:03:51,650 --> 01:03:56,330
>> ಮತ್ತು ಉಲ್ಲೇಖ ಅಂದರೆ ಮೂಲಕ ಕರೆ
ನಾನು ಪ್ರತಿಯನ್ನು ಕಳುಹಿಸುವ ಬಾಗುತ್ತೇನೆ

1188
01:03:56,330 --> 01:03:57,550
ವೇರಿಯಬಲ್ ಸೂಚಕವನ್ನು.

1189
01:03:57,550 --> 01:04:00,970
ಆದ್ದರಿಂದ ನಾನು ಕಳುಹಿಸುವ ನುಡಿದರು ಅರ್ಥ
ವೇರಿಯಬಲ್ ಸ್ಥಳ.

1190
01:04:00,970 --> 01:04:04,440
ಹಾಗಾಗಿ ಸ್ಥಳ ಗ್ರಹಿಸಬಲ್ಲುದು
ವೇರಿಯಬಲ್, ನಾನು ಕಾಲ್ ಕಾರ್ಯ

1191
01:04:04,440 --> 01:04:09,700
ಪಾಯಿಂಟರ್ಸ್, ನಾನು ನೀಡಲು ಸಾಧ್ಯವಾಯಿತು
ಮುಖ್ಯ ಎಂದು ದತ್ತಾಂಶವನ್ನು ಬದಲಾಯಿಸಲು.

1192
01:04:09,700 --> 01:04:12,050
ಅರ್ಥ?

1193
01:04:12,050 --> 01:04:17,560
>> ಆದಾಗ್ಯೂ, ಪಾಯಿಂಟರ್ ಪ್ರತಿಯನ್ನು, ಆಗಿದೆ
ಪಾಯಿಂಟರ್ ಇನ್ನೂ ನೈಜ ವಿಳಾಸ ಹೊಂದಿದೆ

1194
01:04:17,560 --> 01:04:20,090
ನಾನು ಬದಲಾಯಿಸಲು ಬಯಸುವ ವೇರಿಯಬಲ್.

1195
01:04:20,090 --> 01:04:21,920
ಅರ್ಥ?

1196
01:04:21,920 --> 01:04:24,290
>> ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ಸ್ ರಚಿಸುವ.

1197
01:04:24,290 --> 01:04:28,410
ಯಾವಾಗಲೂ ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ ನೆನಪಿಡಿ
ಇದು ತೋರುಗಡ್ಡಿ ರೀತಿಯ

1198
01:04:28,410 --> 01:04:29,890
ನಕ್ಷತ್ರ ಮತ್ತು ನಂತರ.

1199
01:04:29,890 --> 01:04:31,030
ತದನಂತರ ನೀವು ಹೆಸರನ್ನು ಹಾಕಲು.

1200
01:04:31,030 --> 01:04:35,765
ಆದ್ದರಿಂದ ನೀವು ಇದ್ದಾಗಲೆಲ್ಲಾ ನೆನಪು
ಯಾವುದೇ ಸ್ಟಾರ್, ಇದು ಒಂದು ಪಾಯಿಂಟರ್ ಹೀಗಿದೆ

1201
01:04:35,765 --> 01:04:38,990
ಏನೇ ವೇರಿಯಬಲ್
ನೀವು ಎಂದು ಟೈಪ್.

1202
01:04:38,990 --> 01:04:42,850
>> ಇಲ್ಲಿ ಸ್ಟಾರ್, ಉದಾಹರಣೆಗೆ, ಇದು ಇಲ್ಲಿದೆ
ಒಂದು ಪಾಯಿಂಟರ್ ಮತ್ತು ಒಂದು ಪೂರ್ಣಾಂಕ.

1203
01:04:42,850 --> 01:04:47,680
ನಂತರ ಚಾರ್ ಸ್ಟಾರ್ ಸೂಚಿಯಾಗಿದೆ
ಚಾರ್ ಸ್ಟಾರ್ ಇತ್ಯಾದಿ.

1204
01:04:47,680 --> 01:04:47,960
ಹೌದು?

1205
01:04:47,960 --> 01:04:52,710
>> ಪ್ರೇಕ್ಷಕರು: ನಾವು ಹೊಂದಿದ್ದರೆ ಒಂದು
ಎನ್ ಪಾಯಿಂಟರ್ X ನಟಿಸಲು.

1206
01:04:52,710 --> 01:04:55,255
ನಾನು X ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ರಚಿಸುತ್ತದೆ ತಿಳಿದಿರುವ.

1207
01:04:55,255 --> 01:04:59,432
ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ X ಘೋಷಿಸಲು ಡಸ್?

1208
01:04:59,432 --> 01:05:05,170
>> LUCAS: ಸರಿ, ಆದ್ದರಿಂದ ನೀವು ಎನ್ ಸ್ಟಾರ್ X ಹೇಳುವುದಾದರೆ,
ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ರಚಿಸಲು ಇಲ್ಲ

1209
01:05:05,170 --> 01:05:06,000
ವ್ಯತ್ಯಯ X.

1210
01:05:06,000 --> 01:05:08,170
ನೀವು X ಎಂಬ ಪಾಯಿಂಟರ್ ರಚಿಸುತ್ತಿದೆ.

1211
01:05:08,170 --> 01:05:09,396
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1212
01:05:09,396 --> 01:05:14,250
>> LUCAS: ನಾನು ಎನ್ ಸ್ಟಾರ್ X ಹೇಳುತ್ತಾರೆ, ನಾನು
ಹೇ, ನೆನಪಿಗಾಗಿ, ನಾನು ಹೋಗುವ ಬಾಗುತ್ತೇನೆ, ಹೇಳುವ

1213
01:05:14,250 --> 01:05:16,390
ಈ ಮೂರು ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಒಂದು ಪಡೆಯಲು.

1214
01:05:16,390 --> 01:05:20,750
ಮತ್ತು ನಾನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಇದು ಎಕ್ಸ್ ಏರಲಿದೆ

1215
01:05:20,750 --> 01:05:22,000
ಹೋಗುವ ಒಂದು ಪಾಯಿಂಟರ್ ಎಂದು.

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಆಸಕ್ತಿದಾಯಕ ಏನೋ
ನಾವು ಅವರು ಹೇಳುವುದು ಎಂದು

1218
01:05:30,640 --> 01:05:32,620
ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರ 4 ಬೈಟ್ಗಳು.

1219
01:05:32,620 --> 01:05:36,320
ಮತ್ತು ಆ ಕಾರಣಕ್ಕಾಗಿ ಏಕೆಂದರೆ
4 ಬೈಟ್ಗಳು 32 ಬಿಟ್ಗಳು ಇವೆ.

1220
01:05:36,320 --> 01:05:40,490
>> 64 ಬಿಟ್ಗಳು ವಾಸ್ತವವಾಗಿ ಎಂದು ಮತ್ತು ಯಂತ್ರಗಳು
ಪಾಯಿಂಟರ್ಸ್ ವಿಳಾಸಗಳನ್ನು ಹೊಂದಿವೆ

1221
01:05:40,490 --> 01:05:43,480
64 ಬಿಟ್ಗಳು ಉದ್ದವಾಗಿರುತ್ತದೆ.

1222
01:05:43,480 --> 01:05:49,820
ಆದ್ದರಿಂದ ಕೇವಲ ಅರ್ಥ ಗಾತ್ರ
ಯಂತ್ರದಲ್ಲಿ ವಿಳಾಸಗಳನ್ನು ವಿಭಿನ್ನವಾಗಿದೆ.

1223
01:05:49,820 --> 01:05:52,270
>> ಆದ್ದರಿಂದ ಆಕರ ಮತ್ತು Dereferencing.

1224
01:05:52,270 --> 01:05:54,310
ಎರಡು ನಿರ್ವಾಹಕರು ಎಂದು
ನೀವು ಹುಡುಗರಿಗೆ ನೆನಪಿಡಿ ಮಾಡಬೇಕು.

1225
01:05:54,310 --> 01:05:55,450
ಮೊದಲ ವನ್ನಾಗಲಿ ಆಗಿದೆ.

1226
01:05:55,450 --> 01:05:56,810
ಎರಡನೇ ನಟ.

1227
01:05:56,810 --> 01:06:05,060
ಸ್ಟಾರ್ ಮತ್ತು ಈ ಮೂಲಕ ತಪ್ಪಾಗಿ ಮಾಡಬೇಡಿ
ಏಕೆಂದರೆ, ನೆನಪು ಸ್ಟಾರ್

1228
01:06:05,060 --> 01:06:06,950
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು N ನಕ್ಷತ್ರ.

1229
01:06:06,950 --> 01:06:08,700
>> ಅಂತಹವರು ಇಡೀ ವಿಷಯ ಹೀಗಿದೆ.

1230
01:06:08,700 --> 01:06:10,720
ಯಾವುದೇ ಎನ್ ಬಾಹ್ಯಾಕಾಶ ನಕ್ಷತ್ರ ಇಲ್ಲ.

1231
01:06:10,720 --> 01:06:12,070
ಆದ್ದರಿಂದ ಇದು ರೀತಿಯ ಎಂದು ಅರ್ಥ.

1232
01:06:12,070 --> 01:06:14,870
ನೀವು ಹೊಂದಿರುವ ಆ ನೆನಪಿಡಿ
ನಕ್ಷತ್ರಗಳ ವಿಭಿನ್ನ, ನೀವು

1233
01:06:14,870 --> 01:06:16,230
ರೀತಿಯ ಬಗ್ಗೆ.

1234
01:06:16,230 --> 01:06:20,540
>> ನೀವು ನಂತರ ಕೇವಲ ಸ್ಟಾರ್ ಮತ್ತು ಹೊಂದಿರುವಾಗ
ವೇರಿಯೇಬಲ್ ಹೆಸರನ್ನು, ಇದು ಅರ್ಥ

1235
01:06:20,540 --> 01:06:24,100
ನೀವು ಪಾಯಿಂಟರ್, dereferencing ನೀವು ಯಾವ
ನೀವು ಹುಡುಕುತ್ತಿರುವ ಎಂದು ಅರ್ಥ

1236
01:06:24,100 --> 01:06:28,290
ಪಾಯಿಂಟರ್, ವಿಳಾಸ ಹುಡುಕುವ ಅಷ್ಟೇ
, ತೋರುತ್ತಿರುವಂತೆ ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ,

1237
01:06:28,290 --> 01:06:30,850
ಮತ್ತು ಬಂದ ನೋಡುವ
ನೀವು ಹೊಂದಿರುವ.

1238
01:06:30,850 --> 01:06:34,310
ಹಾಗಾಗಿ ನೀವು ಹೊಂದಿರುವ ಆ ನನ್ನ ವಿದ್ಯಾರ್ಥಿಗಳು ತಿಳಿಸಿ
ಸ್ಟಾರ್, ನೀವು ಎಂದು ಯೋಚಿಸಬೇಕು

1239
01:06:34,310 --> 01:06:36,850
ವಿಷಯದ ಸಂಕ್ಷೇಪಣ.

1240
01:06:36,850 --> 01:06:39,770
>> ನೀವು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ ಆದ್ದರಿಂದ ನೀವು
ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್ ಮಾಡಲು, ಅಷ್ಟೇ

1241
01:06:39,770 --> 01:06:41,720
ಪಾಯಿಂಟರ್ ವಿಷಯ.

1242
01:06:41,720 --> 01:06:44,580
ಆದ್ದರಿಂದ ನೀವು ಅದನ್ನು ತೋರಿಸುವ ಯಾವುದೇ ಹೋಗಿ
ಮತ್ತು ನಿರಂತರ ವಿಷಯವನ್ನು ನೋಡಲು.

1243
01:06:44,580 --> 01:06:47,730
ಮತ್ತು ವನ್ನಾಗಲಿ ಒಂದೇ
ವಿಳಾಸಗಳಂತಹ ವಿಷಯ.

1244
01:06:47,730 --> 01:06:52,560
>> ನಾನು ಹಾಗೆ a-- ವೇರಿಯಬಲ್ ಹೊಂದಿದ್ದರೆ ಆದ್ದರಿಂದ, ನ ಅವಕಾಶ
ಇಂಟ್ ಒಂದು ಸಮನಾಗಿರುತ್ತದೆ ನಾನು ಎಂದು ಹೇಳಲು 3 ಹೀಗೆ

1245
01:06:52,560 --> 01:06:56,900
ನಾನು ಆ ವಿಳಾಸ ಹುಡುಕಲು ಬಯಸಿದರೆ
ವೇರಿಯಬಲ್ ಒಂದು ಮೆಮೊರಿ, ನಾನು ಮಾಡಬಹುದು

1246
01:06:56,900 --> 01:06:58,240
ಒಂದು ವನ್ನಾಗಲಿ.

1247
01:06:58,240 --> 01:07:00,280
ಆದ್ದರಿಂದ ಒಂದು ವಿಳಾಸಕ್ಕೆ ಇಲ್ಲಿದೆ.

1248
01:07:00,280 --> 01:07:01,530
ಅರ್ಥ?

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> ಇಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ.

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
ಈ ಇಂಟ್ ಬೌ ಮತ್ತು ಇಂಟ್ ಸಿ ಕಾಣೆಯಾಗಿದೆ.

1253
01:07:11,530 --> 01:07:16,520
ಒಂದು 3 ಸಾಧನವಾಗಿ ಸಮನಾಗಿರುತ್ತದೆ ಇಂಟ್ ಆದ್ದರಿಂದ
ನಾನು ಮೆಮೊರಿ ಹೋಗಲು ಪಡೆಯಲಿದ್ದೇನೆ.

1254
01:07:16,520 --> 01:07:19,870
ನಾನು ಒಂದು ಸ್ಲಾಟ್ ಹುಡುಕಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಮತ್ತು ಇಲ್ಲಿ ಸಂಖ್ಯೆ 3 ಪುಟ್.

1255
01:07:19,870 --> 01:07:22,200
>> ತದನಂತರ ಇಂಟ್ ಬೌ 4 ಸಮನಾಗಿರುತ್ತದೆ.

1256
01:07:22,200 --> 01:07:23,100
ಒಂದೇ ವಿಷಯವನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ.

1257
01:07:23,100 --> 01:07:25,840
ಮೆಮೊರಿ ಹೋಗಿ ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ನೀಡಿ
ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಒಂದು 4.

1258
01:07:25,840 --> 01:07:27,100
ಮತ್ತು ಇಂಟ್ 5 ಸಮನಾಗಿರುತ್ತದೆ.

1259
01:07:27,100 --> 01:07:29,740
ಮತ್ತೊಂದು ಬಾಕ್ಸ್ ಹುಡುಕಲು ಮತ್ತು ಸಂಖ್ಯೆ 5 ಪುಟ್.

1260
01:07:29,740 --> 01:07:36,160
>> ಆದ್ದರಿಂದ ಔಟ್ ಮಾಡುವ ಈ ಸಾಲಿನ ಏನು?
ಎನ್ ಸ್ಟಾರ್ ಪಾ ವನ್ನಾಗಲಿ ಒಂದು ಸಮನಾಗಿರುತ್ತದೆ.

1261
01:07:36,160 --> 01:07:37,800
ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಮೊದಲ, ಎನ್ ಸ್ಟಾರ್ ಪಾ.

1262
01:07:37,800 --> 01:07:39,050
ಇದು ಏನು?

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1265
01:07:42,298 --> 01:07:47,890
>> LUCAS: ಹೌದು, ಆದ್ದರಿಂದ N ಸ್ಟಾರ್ ಪಾ, ಮೊದಲ,
PA ಎಂಬ ಪಾಯಿಂಟರ್ ಘೋಷಿಸುತ್ತದೆ.

1266
01:07:47,890 --> 01:07:53,720
ನಂತರ ಅದನ್ನು ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುವ ನ
ಪಾಯಿಂಟರ್ ಒಂದು ವಿಳಾಸಕ್ಕೆ ಎಂದು.

1267
01:07:53,720 --> 01:07:55,790
ಆದ್ದರಿಂದ ಒಂದು ವನ್ನಾಗಲಿ.

1268
01:07:55,790 --> 01:07:58,510
ನಂತರ, ನಾನು ಸ್ಟಾರ್ ಪಿಬಿ ಹೋದರೆ,
ನಕ್ಷತ್ರ ಪಿಬಿ ಏನು?

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> ಓಹ್, ಕ್ಷಮಿಸಿ.

1271
01:08:03,150 --> 01:08:06,330
ಇದು ಕಾಣೆಯಾಗಿದೆ. ಎನ್ ಸ್ಟಾರ್ ಪಿಬಿ.

1272
01:08:06,330 --> 01:08:07,905
ನಾನು ಸ್ಟಾರ್ ಪಿಸಿ ಅರ್ಥ.

1273
01:08:07,905 --> 01:08:11,200
ನಾನು ಕ್ಷಮಿಸಿ.

1274
01:08:11,200 --> 01:08:11,940
ಅದೇ ವಿಷಯ.

1275
01:08:11,940 --> 01:08:16,408
ಆದರೆ ಈಗ ನಾನು ಪಾಯಿಂಟರ್ ರಚಿಸುವ AR ಒಳ್ಳೆಯ ಮನುಷ್ಯ
ನಂತರ ಸಿ ಒಂದು ಪಾಯಿಂಟರ್ ಬೌ ಮತ್ತು.

1276
01:08:16,408 --> 01:08:16,886
ಹೌದು?

1277
01:08:16,886 --> 01:08:18,136
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> LUCAS: ಹೌದು.

1280
01:08:26,670 --> 01:08:32,630
ಆದ್ದರಿಂದ ನೀವು ಮೆಮೊರಿ ಹೋಗಿ ಮತ್ತು ನೀವು ಹೋಗಿ
PA ಫಾರ್ ನಿಯೋಜಕ ಎಂದು ಬಾಕ್ಸ್,

1281
01:08:32,630 --> 01:08:37,149
ನಿಜವಾಗಿಯೂ ನೀನು
ಒಂದು ಒಂದು ವಿಳಾಸಕ್ಕೆ ನೋಡಿ.

1282
01:08:37,149 --> 01:08:38,399
ಸರಿ?

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
ಹೌದು?

1285
01:08:43,300 --> 01:08:45,605
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1286
01:08:45,605 --> 01:08:49,260
>> LUCAS: ಹೌದು, ಪಾಯಿಂಟರ್ ಒಂದು ವಿಳಾಸ.

1287
01:08:49,260 --> 01:08:50,120
ಆ.

1288
01:08:50,120 --> 01:08:52,800
ಇದು ಪ್ರಮುಖ ಹೀಗಿದೆ
ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ಭಾಗವಾಗಿ.

1289
01:08:52,800 --> 01:08:56,180
ಸಂಗ್ರಹಿಸುವ ಮತ್ತು ವಿಳಾಸ ಇಲ್ಲ
ಕೆಲವು ವೇರಿಯಬಲ್.

1290
01:08:56,180 --> 01:08:56,890
ಬೇರೆ ಏನು?

1291
01:08:56,890 --> 01:08:58,370
ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

1292
01:08:58,370 --> 01:08:59,189
ಸರಿ.

1293
01:08:59,189 --> 01:09:00,399
>> ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ಅರೆಸ್.

1294
01:09:00,399 --> 01:09:08,189
ನೆನಪಿಡಿ ನಾನು ರಚನೆಯ 3 ಇಂಟ್ ಮಾಡಿದಾಗ,
ಮೂಲತಃ, ನಾನು ಏನು ಮಾಡುತ್ತಿರುವೆ ನಾನು ರೀತಿಯ, ನನಗೆ

1295
01:09:08,189 --> 01:09:12,779
ಆಫ್, ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸುವ.

1296
01:09:12,779 --> 01:09:18,960
ಆದ್ದರಿಂದ ರಚನೆಯ ರೀತಿಯ ಒಂದು ಪಾಯಿಂಟರ್ ರೀತಿಯ
ನೆನಪಿಗಾಗಿ ನಿರ್ದಿಷ್ಟ ಸ್ಥಳದಲ್ಲಿ ಇದರಲ್ಲಿ ನಾನು

1297
01:09:18,960 --> 01:09:21,999
ಪೂರ್ಣಾಂಕಗಳು ಮೂರು ಅವಕಾಶಗಳನ್ನು ಹಂಚಿಕೆ.

1298
01:09:21,999 --> 01:09:23,430
ಎಂದು ಅರ್ಥ ಡಸ್?

1299
01:09:23,430 --> 01:09:30,250
>> ನಾನು ಇಂಟ್ ರಚನೆಯ 3 ಮಾಡಿದಾಗ ಆದ್ದರಿಂದ, ನಾನು ಏನು ನಾನು
ಮಾಡುವ, ಮೂಲತಃ, ಮೂರು ರಚಿಸುತ್ತಿದೆ

1300
01:09:30,250 --> 01:09:31,479
ಮೆಮೊರಿ ಸ್ಲಾಟ್ಗಳು.

1301
01:09:31,479 --> 01:09:33,899
ಆದ್ದರಿಂದ ನಾನು ನೆನಪಿಗಾಗಿ ಮೂರು ಅವಕಾಶಗಳನ್ನು ಹೇಗೆ.

1302
01:09:33,899 --> 01:09:38,810
ಹಾಗಾಗಿ, ನಂತರ, ನಕ್ಷತ್ರ ರಚನೆಯ, ಅದನ್ನು ವೇಳೆ
ಮೂಲತಃ ರಚನೆಯ ವಿಷಯವನ್ನು ಅರ್ಥ,

1303
01:09:38,810 --> 01:09:46,180
ಇದು ನಾನು ಹೋಗಿ, ನಾನು ಪಾಯಿಂಟರ್ ಅಳಿಸಿ ಅರ್ಥ
ಇದು ತೋರಿಸುವ ಎಂದು ಆ ಸ್ಥಳಕ್ಕೆ,

1304
01:09:46,180 --> 01:09:47,939
ಮತ್ತು ನಾನು ಒಂದನೇ ಪುಟ್.

1305
01:09:47,939 --> 01:09:53,729
>> ನಂತರ, ನಾನು ಸ್ಟಾರ್ ರಚನೆಯ ಜೊತೆಗೆ 1 ಹೋದರೆ,
ವ್ಯೂಹ ಮಾಡುವ ಅದೇ ವಿಷಯ

1306
01:09:53,729 --> 01:09:59,690
ನಾನು ಹೋಗಿ ಅಂದರೆ, ಒಂದು ಆವರಣ
ಇದು ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಸ್ಥಾನ.

1307
01:09:59,690 --> 01:10:03,000
ತದನಂತರ ಜೊತೆಗೆ 1 ಮಾದರಿಗಳ
ನನಗೆ ಒಂದು ಸ್ಥಾನ ಪಲ್ಲಟ.

1308
01:10:03,000 --> 01:10:06,510
ಹಾಗಾಗಿ, ವಾಸ್ತವವಾಗಿ, ಈ ಸ್ಥಾನವನ್ನು ಹೋಗಿ
ಮತ್ತು ಎರಡು ಪುಟ್.

1309
01:10:06,510 --> 01:10:10,900
>> ನಂತರ, ಅಂತಿಮವಾಗಿ, ನಾನು ಮಾಡಲು
ರಚನೆಯ ಜೊತೆಗೆ 2, ನಾನು ಅಲ್ಲಿ ಹೋಗಿ

1310
01:10:10,900 --> 01:10:11,825
ನಲ್ಲಿ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುವ.

1311
01:10:11,825 --> 01:10:14,690
ಮತ್ತು ನಂತರ ನಾನು ಮೆಮೊರಿ ಬ್ಲಾಕ್ಗಳನ್ನು ಸರಿಸಲು.

1312
01:10:14,690 --> 01:10:16,240
ನಂತರ ನಾನು ಇಲ್ಲಿ ಸಂಖ್ಯೆ ಮೂರು ಪುಟ್.

1313
01:10:16,240 --> 01:10:16,600
ಹೌದು?

1314
01:10:16,600 --> 01:10:21,400
>> ಪ್ರೇಕ್ಷಕರು: ಸ್ಟಾರ್ ರಚನೆಯ ಕೇವಲ ಆಗಿದೆ
ಮೊದಲ ಹಂತದಲ್ಲಿ ಹೇಳುವ.

1315
01:10:21,400 --> 01:10:25,090
ಮತ್ತು ನೀವು ಕೇವಲ, 1 ಸೇರಿಸಬಹುದು
ನಾವು ನಿಜವಾಗಿಯೂ ಆರ್

1316
01:10:25,090 --> 01:10:27,295
ಮೊದಲ ವಿಳಾಸ ಗುರುತಿಸಲಾಗುತ್ತಿದೆ.

1317
01:10:27,295 --> 01:10:28,545
>> LUCAS: ಹೌದು.

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
ಏಕೆ ನಾವು, ಉದಾಹರಣೆಗೆ, ರಚನೆಯ ಹೇಳುತ್ತಾರೆ ಇಲ್ಲ
0, ಸರಣಿ 1, ಮತ್ತು ರಚನೆಯ 2?

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
ನಾನು, ಏಕೆ 0 ಮಾಡಬೇಕು, ಹೇಳುವ ನಾನು
1, 2, 3 ಬದಲಿಗೆ 1, 2, 3?

1322
01:10:42,790 --> 01:10:46,550
ಕಾರಣಗಳೆಂದರೆ, ಒಂದು, ಕಂಪ್ಯೂಟರ್
ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಆರಂಭಿಸಲು ಆದ್ಯತೆ

1323
01:10:46,550 --> 01:10:47,750
0 ಇಂದ ಲೆಕ್ಕ.

1324
01:10:47,750 --> 01:10:52,370
ನೀವು ರಚನೆಯ 0 ಮಾಡಿದಾಗ ಏಕೆಂದರೆ ಎರಡು, ಆಗಿದೆ
ಇದು ರಚನೆಯ ಮಾಡುವ ಅದೇ ವಿಷಯ

1325
01:10:52,370 --> 01:10:56,330
ಅಂದರೆ ಜೊತೆಗೆ 0, ನಾನು ಹೋಗಿ
ಆ ಸ್ಥಾನದಲ್ಲಿ, ಮತ್ತು ನಾನು ಹಾಗೆ

1326
01:10:56,330 --> 01:10:59,320
ಯಾವುದೇ ಮೆಮೊರಿ ಬ್ಲಾಕ್ಗಳನ್ನು ತೆರಳಿ.

1327
01:10:59,320 --> 01:11:01,750
ಹಾಗಾಗಿ ಯಾವುದೇ ಮೆಮೊರಿ ಬ್ಲಾಕ್ಗಳನ್ನು ಚಲಿಸುವುದಿಲ್ಲ.

1328
01:11:01,750 --> 01:11:02,015
ಹೌದು?

1329
01:11:02,015 --> 01:11:03,265
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> LUCAS: ಆಕೆ ಏನು ಕೇಳುತ್ತಿದೆ
ಮಾಡುವ ನಡುವಿನ ವ್ಯತ್ಯಾಸ

1332
01:11:12,670 --> 01:11:14,000
ಈ ಅಥವಾ malloc ಮಾಡುವ.

1333
01:11:14,000 --> 01:11:17,550
ವ್ಯತ್ಯಾಸವೆಂದರೆ ಎಂದು
ಇಂಟ್ ರಚನೆಯ 3 ಒಂದು ರಚಿಸುತ್ತಿದೆ

1334
01:11:17,550 --> 01:11:19,260
ಸ್ಟಾಕ್ ಮೇಲೆ ಸರಣಿ.

1335
01:11:19,260 --> 01:11:23,080
ಮತ್ತು ನಾನು malloc ಮಾಡಿದಾಗ, ಇದು
ರಾಶಿ ಸೃಷ್ಟಿಸುತ್ತದೆ.

1336
01:11:23,080 --> 01:11:25,250
ಎಂದು ಅರ್ಥ ಡಸ್?

1337
01:11:25,250 --> 01:11:28,870
>> ಆದ್ದರಿಂದ, malloc ನಿಜವಾಗಿಯೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

1338
01:11:28,870 --> 01:11:32,245
ಆದ್ದರಿಂದ ನಾವು ಕೂಡ malloc ಬಳಸಬಹುದು ಬೇಕು?

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
ವ್ಯಕ್ತಿಗಳ ನಿಮ್ಮ ಕಂಪೈಲರ್ ರೀತಿಯ ಔಟ್ ಎಲ್ಲಾ
ನೀವು ಡಿಕ್ಲೇರ್ಡ್ ಅಸ್ಥಿರ.

1341
01:11:39,700 --> 01:11:44,040
ಅವನು ಎಲ್ಲಾ ಜಾಗವನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ
ಸ್ಟಾಕ್ ಅವುಗಳಲ್ಲಿ.

1342
01:11:44,040 --> 01:11:47,180
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಅಸ್ಥಿರ ಎಲ್ಲಾ ಹೋಗುವ
ಎಲ್ಲೋ ಸ್ಟ್ಯಾಕ್ ಎಂದು.

1343
01:11:47,180 --> 01:11:49,460
ಇಲ್ಲಿ ಪರಿಸರ ಚರಗಳ ಆಗಿದೆ.

1344
01:11:49,460 --> 01:11:53,850
>> ಆ ಅಸ್ಥಿರ ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ಸ್ಪೇಸ್
ನೆನಪಿಗಾಗಿ ನಿಯೋಜಿತವಾದ ಇದೆ

1345
01:11:53,850 --> 01:11:55,080
ಬಾರಿ ಕಂಪೈಲ್.

1346
01:11:55,080 --> 01:11:58,790
ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಹೊಂದಿದೆ ಎಂದರ್ಥ
ಆ ಅಸ್ಥಿರ ಎಲ್ಲಾ ತಿಳಿಯಲು

1347
01:11:58,790 --> 01:11:59,790
ಮೊದಲೇ.

1348
01:11:59,790 --> 01:12:02,500
ಇದು ಯಾವ ಮೌಲ್ಯವನ್ನು ತಿಳಿಯಲು ಅಗತ್ಯವಿಲ್ಲ
ನೀವು ಅವುಗಳನ್ನು ಪುಟ್ ನೀನು.

1349
01:12:02,500 --> 01:12:05,490
ಆದರೆ ಅದು ಹೇಗೆ ತಿಳಿಯಲು ಅಗತ್ಯವಿದೆ
ನೀವು ಹೆಚ್ಚು ಮೆಮೊರಿ.

1350
01:12:05,490 --> 01:12:09,380
>> ಆದರೆ ಈಗ ಉದಾಹರಣೆಗೆ, ಎಂದು ತಿಳಿಸಿ
ನೀವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವ ಅಥವಾ ತೆಗೆದುಕೊಳ್ಳುವ ನೀವು

1351
01:12:09,380 --> 01:12:13,430
ನೀವು ತೆಗೆದುಕೊಳ್ಳುವ ನೀವು ಸ್ಟ್ರಿಂಗ್
ಬಳಕೆದಾರರ.

1352
01:12:13,430 --> 01:12:17,300
ನೀವು ಗೊತ್ತಿಲ್ಲ ಎಷ್ಟು ಸ್ಟ್ರಿಂಗ್
ಉದಾಹರಣೆಗೆ, ಎಂದು ನಾನು.

1353
01:12:17,300 --> 01:12:20,600
ಆದ್ದರಿಂದ ನೀವು ನಿಖರವಾಗಿ ಎಷ್ಟು ಗೊತ್ತಿಲ್ಲ
ಮೆಮೊರಿ ಬ್ಲಾಕ್ಗಳನ್ನು ನೀವು ಬಲ, ನಿಯೋಜಿಸಿ?

1354
01:12:20,600 --> 01:12:24,120
>> ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ
ನೀವು 100 ಪಾತ್ರಗಳು ಹಾಕಲು ಹೇಳಲು.

1355
01:12:24,120 --> 01:12:26,420
ತದನಂತರ ಬಳಕೆದಾರ 150 ಬರೆಯುತ್ತಾರೆ ವೇಳೆ?

1356
01:12:26,420 --> 01:12:27,670
ನೀವು ಹಾಳಾದ ಎಂದು ನೀನು.

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ನೀವು ಹೇಗೆ ಮರೆಯಬೇಡಿ ಸಾಧ್ಯವಿಲ್ಲ
ನೀವು ನಿಯೋಜಿಸಿ ಅಗತ್ಯವಿದೆ ಹೆಚ್ಚು ಮೆಮೊರಿ

1359
01:12:34,620 --> 01:12:35,960
ನೀವು ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್.

1360
01:12:35,960 --> 01:12:38,240
ನೀವು ರನ್ ಸಮಯಕ್ಕೆ ತಿಳಿದಿದೆ.

1361
01:12:38,240 --> 01:12:39,950
ನೀವು ರಾಶಿ ಏಕೆ ಆ ನ.

1362
01:12:39,950 --> 01:12:47,610
ರಾಶಿ ಮೆಮೊರಿ ಮಾಡಲಿಕ್ಕೆ ಇದೆ
ನೀವು ಸಮಯದಲ್ಲಿ ಹಂಚುತ್ತಾರೆ ಎಂದು

1363
01:12:47,610 --> 01:12:50,810
ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಅವಧಿಯು.

1364
01:12:50,810 --> 01:12:55,780
>> ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ, ನೀವು malloc ಮಾಡಿದಾಗ, ಏನು
ನೀವು ಮೆಮೊರಿ ನೀಡಲು ಮಾಡುತ್ತಿರುವುದು

1365
01:12:55,780 --> 01:13:00,160
ನೀವು ಅಂದರೆ ರನ್ಟೈಮ್,
ಆ ಕ್ಷಣದಲ್ಲಿ ಬಲ ನಿರ್ಧರಿಸುವ ನೀವು

1366
01:13:00,160 --> 01:13:02,670
ಮೆಮೊರಿ ಇರಬೇಕು.

1367
01:13:02,670 --> 01:13:04,210
ನೀವು ಹಂಚುತ್ತಾರೆ ಮಾಡಿದಾಗ ಆ ನ.

1368
01:13:04,210 --> 01:13:06,430
ಎಂದು ಅರ್ಥ ಡಸ್?

1369
01:13:06,430 --> 01:13:11,690
>> ಆದ್ದರಿಂದ ಸ್ಟಾಕ್ ಅಸ್ಥಿರಗಳು ಹೊಂದಿದೆ ನೆನಪಿಡಿ
ಆ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಮೇಲೆ ರಚಿಸಲಾಗಿದೆ.

1370
01:13:11,690 --> 01:13:14,560
ತದನಂತರ ರಾಶಿ ಅಸ್ಥಿರಗಳು ಹೊಂದಿದೆ
ನೀವು ಹೋಗಿ ಎಂದು ರಚಿಸಲಾಗಿದೆ ಎಂದು

1371
01:13:14,560 --> 01:13:15,600
ಉದಾಹರಣೆಗೆ, malloc, ಜೊತೆ.

1372
01:13:15,600 --> 01:13:16,850
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> LUCAS: ಆದ್ದರಿಂದ GetString ಆಗಿದೆ
malloc ಕರೆಯಲು ಹೋಗುತ್ತದೆ.

1375
01:13:24,340 --> 01:13:26,710
ನನಗೆ, malloc ಬಗ್ಗೆ ಮಾತನಾಡೋಣ, ಮತ್ತು
ನಾನು GetString ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ.

1376
01:13:26,710 --> 01:13:32,000
ಆದ್ದರಿಂದ malloc ಅದೇ ವಿಷಯ
ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಎಂದು.

1377
01:13:32,000 --> 01:13:34,600
ಆದ್ದರಿಂದ ನಿಯೋಜಿಸಿ ವಿಶೇಷವೇನು
ರಾಶಿ ಮೆಮೊರಿಯ.

1378
01:13:34,600 --> 01:13:40,010
ಮತ್ತು ಇದು ಒಂದು ಪಾಯಿಂಟರ್ ಮರಳಲು ವಿಶೇಷವೇನು
ಅಲ್ಲಿ ಮೆಮೊರಿ ನಲ್ಲಿ ಹಂಚಲಾಯಿತು.

1379
01:13:40,010 --> 01:13:43,090
>> ಆದ್ದರಿಂದ ನೀವು do-- ಮಾಡಿದಾಗ

1380
01:13:43,090 --> 01:13:44,910
ಇಲ್ಲಿ ಉದಾಹರಣೆಗೆ ಫಾರ್

1381
01:13:44,910 --> 01:13:45,830
ಎನ್ ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್.

1382
01:13:45,830 --> 01:13:50,520
ತದನಂತರ ಪಾಯಿಂಟರ್, malloc ಸಮನಾಗಿರುತ್ತದೆ
ಇಂಚು ಬಾರಿ 10 ಗಾತ್ರವನ್ನು.

1383
01:13:50,520 --> 01:13:52,110
ನಾನು ಪಾಯಿಂಟರ್ ರಚಿಸುವ ನಾನು.

1384
01:13:52,110 --> 01:13:59,020
ತದನಂತರ ನಾನು ಎಂದು ಪಾಯಿಂಟರ್ ನಿಯೋಜಿಸುವ ನಾನು
ಸೂಚಿಗೆ, malloc ಮೌಲ್ಯವನ್ನು

1385
01:13:59,020 --> 01:13:59,680
ನನಗೆ ನೀಡಿದ್ದಾರೆ.

1386
01:13:59,680 --> 01:14:04,150
>> ಹಾಗಾಗಿ ಕೇಳುವ ಬಾಗುತ್ತೇನೆ malloc ನೀವು ನಿಯೋಜಿಸಿ
10 ಪೂರ್ಣಾಂಕಗಳು ಜಾಗವನ್ನು.

1387
01:14:04,150 --> 01:14:05,390
ಅದು ಹೇಳುವ ಇಲ್ಲಿದೆ.

1388
01:14:05,390 --> 01:14:09,020
ಮತ್ತು malloc ಮರಳಿ ನನಗೆ ನೀಡುತ್ತದೆ ಒಂದು
ಆ ಸ್ಥಳದಲ್ಲಿ ಸೂಚಕವನ್ನು.

1389
01:14:09,020 --> 01:14:11,460
ಅರ್ಥ?

1390
01:14:11,460 --> 01:14:12,270
ಸರಿ.

1391
01:14:12,270 --> 01:14:17,940
ನಾನು ಮತ್ತು GetString, ಮೂಲತಃ, ಒಂದು ಮಾಡುತ್ತಿರುವ
ನೀವು ನಿಯೋಜಿಸಿ ಆದ್ದರಿಂದ malloc ಕರೆ

1392
01:14:17,940 --> 01:14:21,680
ಚಾಲನಾ ಸಮಯದಲ್ಲಿ ಮೆಮೊರಿ.

1393
01:14:21,680 --> 01:14:26,460
>> ಯಾವಾಗಲೂ ಶೂನ್ಯ ಪರಿಶೀಲಿಸಲು ನೆನಪು
malloc ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮರಳಿ ಹೋಗುವ ಏಕೆಂದರೆ

1394
01:14:26,460 --> 01:14:28,200
ಇದು ಮೆಮೊರಿ ಸಾಧ್ಯವಿಲ್ಲ.

1395
01:14:28,200 --> 01:14:31,660
ನ ನೀವು ಹಾಸ್ಯಾಸ್ಪದ ಕೇಳುವುದಿಲ್ಲ ಎಂದು ಹೇಳಿ ನೋಡೋಣ
ಮೆಮೊರಿಯ ಪ್ರಮಾಣವನ್ನು.

1396
01:14:31,660 --> 01:14:33,950
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಹಿಂದಿರುಗಬಹುದೆಂದು ಇದೆ
ಹೆಚ್ಚು ನಿಯೋಜಿಸಿ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

1397
01:14:33,950 --> 01:14:36,410
>> ಆದ್ದರಿಂದ malloc ಕೇವಲ ಹೋಗುತ್ತದೆ
ಶೂನ್ಯ ಮರಳಲು.

1398
01:14:36,410 --> 01:14:42,210
ಆದ್ದರಿಂದ ಯಾವಾಗಲೂ ಪರೀಕ್ಷಿಸಲು ಮರೆಯದಿರಿ
ನೀವು malloc ಕೊಂಡಿರುವ ಪಾಯಿಂಟರ್

1399
01:14:42,210 --> 01:14:45,640
ಶೂನ್ಯ ಅಥವಾ ಇದು ವೇಳೆ, ನೀವು, ಏಕೆಂದರೆ
ಒಂದು ಪಾಯಿಂಟರ್ dereferencing ಮಾಡಲು ಮತ್ತು

1400
01:14:45,640 --> 01:14:48,340
ಅಡ್ಡ ದೋಷಗಳನ್ನು ಕಾರಣವಾಗುತ್ತದೆ.

1401
01:14:48,340 --> 01:14:50,930
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಮರೆಯಬೇಡಿ
ನಿಮ್ಮ ಮೆಮೊರಿಯನ್ನು.

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> Malloc ಹೇರಳ ಮೆಮೊರಿ ರಚಿಸುತ್ತಿದೆ.

1404
01:15:00,560 --> 01:15:03,436
ಮತ್ತು ನೀವು ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮೊದಲು.

1405
01:15:03,436 --> 01:15:05,370
ಸರಿ, ನನಗೆ ಎಲ್ಲಾ ಇಲ್ಲಿದೆ.

1406
01:15:05,370 --> 01:15:07,900
ಕ್ಷಮಿಸಿ, ರಾಬ್.

1407
01:15:07,900 --> 01:15:07,950
ಧನ್ಯವಾದಗಳು.

1408
01:15:07,950 --> 01:15:09,878
>> [ಚಪ್ಪಾಳೆಯನ್ನು]

1409
01:15:09,878 --> 01:15:12,679
>> LUCAS: ಯಾವುದೇ ಕೊನೆಯಾಗಿ ಪ್ರಶ್ನೆಗಳು
ರಾಬ್ ಬರುತ್ತದೆ ಮೊದಲು?

1410
01:15:12,679 --> 01:15:13,138
ಯಾವುದೇ?

1411
01:15:13,138 --> 01:15:13,597
ಹೌದು?

1412
01:15:13,597 --> 01:15:15,892
>> ಪ್ರೇಕ್ಷಕರು: ನಾನು ನೋಡಲಿಲ್ಲ
ಈ ಒಂದು ಆನ್ಲೈನ್.

1413
01:15:15,892 --> 01:15:17,269
ಇನ್ನೂ ಅಪ್ಲೋಡ್?

1414
01:15:17,269 --> 01:15:19,106
>> LUCAS: ನಾನು ಡೇವ್ ಎಂದು
ಶೀಘ್ರದಲ್ಲೇ ಅಪ್ಲೋಡ್.

1415
01:15:19,106 --> 01:15:19,880
>> ಡೇವ್: ಇದು ಪೋಸ್ಟ್ ಮಾಡುತ್ತೇವೆ.

1416
01:15:19,880 --> 01:15:20,310
>> LUCAS: ಇದು ಆನ್ಲೈನ್ ಮಾಡುತ್ತೇವೆ.

1417
01:15:20,310 --> 01:15:21,175
>> ಪ್ರೇಕ್ಷಕರು: ಬಿಟ್ಟಿದ್ದು.

1418
01:15:21,175 --> 01:15:22,090
>> LUCAS: ಇದು ಬಿಟ್ಟಿದ್ದು?

1419
01:15:22,090 --> 01:15:23,157
ಸರಿ.

1420
01:15:23,157 --> 01:15:23,644
ಹೌದು?

1421
01:15:23,644 --> 01:15:27,053
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1422
01:15:27,053 --> 01:15:30,285
>> LUCAS: ಹೌದು, ನೀವು ಬಿಡುಗಡೆ ಮಾಡಬೇಕು ಎಲ್ಲಾ
ರಾಶಿ ಹಾಕಲಾಗುತ್ತದೆ ಎಂದು ಮೆಮೊರಿ.

1423
01:15:30,285 --> 01:15:31,535
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> LUCAS: ಹೌದು.

1426
01:15:36,160 --> 01:15:39,980
ನೀವು ಸಂಸ್ಕೃತಿ, malloc ಯಾವುದೇ ಸಮಯ,
ನೀವು ಉಚಿತ ಸಂಸ್ಕೃತಿ ಇರಬೇಕು

1427
01:15:39,980 --> 01:15:42,640
ನೀವು ನಂತರ ವೇರಿಯಬಲ್ ಬಳಸಿ ನಿಲ್ಲಿಸಲು.

1428
01:15:42,640 --> 01:15:44,800
ಆದ್ದರಿಂದ malloc ಮತ್ತು ಉಚಿತ
ಯಾವಾಗಲೂ ಒಟ್ಟಿಗೆ.

1429
01:15:44,800 --> 01:15:45,410
ತಮ್ಮ ಉತ್ತಮ ಸ್ನೇಹಿತರು.

1430
01:15:45,410 --> 01:15:46,720
ಹೌದು.

1431
01:15:46,720 --> 01:15:47,970
ರಾಬ್?

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> ರಾಬ್: ನಾನು ಬೇಗ ಹೋಗುತ್ತೇನೆ.

1434
01:15:56,850 --> 01:16:00,466
ಮತ್ತು ವಿಡಿಯೋ ಅಪ್ ಮಾಡಲಿದೆ.

1435
01:16:00,466 --> 01:16:01,716
ನಾನು ಮೈಕ್ ಹೊಂದಿವೆ.

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> ಸರಿ, ಆದ್ದರಿಂದ ವಾರದಲ್ಲಿ ಐದು ಸ್ಟಫ್.

1438
01:16:26,230 --> 01:16:27,970
ನಾವು ಮೊದಲನೆಯದಾಗಿ ರಾಶಿಯಿದೆ.

1439
01:16:27,970 --> 01:16:33,390
ಆದ್ದರಿಂದ ಒಂದೇ ಸ್ಟಾಕ್ ಇಲ್ಲ ಎಂದು ನೆನಪಿಡಿ
ಸಕ್ರಿಯ ಕಾರ್ಯ ಕರೆ ಪ್ರತಿ ಫ್ರೇಮ್.

1440
01:16:33,390 --> 01:16:34,710
ನಾವು ಎರಡನೇ ಎಂದು ನೋಡುತ್ತಾರೆ.

1441
01:16:34,710 --> 01:16:37,850
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ
ಪ್ರತಿ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಮುಂದುವರೆಸುತ್ತೇವೆ

1442
01:16:37,850 --> 01:16:41,880
ನಮ್ಮ ಕಾರ್ಯಗಳನ್ನು ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು,
ರವಾನಿಸಲ್ಪಡುತ್ತದೆ ವಾದಗಳು ನಮ್ಮ

1443
01:16:41,880 --> 01:16:43,880
ಒಂದೆರಡು ಜೊತೆಗೆ ಕಾರ್ಯಗಳನ್ನು
ಇತರ ವಿಷಯಗಳ ನೀನು

1444
01:16:43,880 --> 01:16:45,260
ಬಗ್ಗೆ ಚಿಂತೆ ಅಗತ್ಯವಿದೆ.

1445
01:16:45,260 --> 01:16:50,950
>> ಇಲ್ಲಿ ಅಲ್ಲಿ ಒಂದು ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ,
ಸೂಚನೆ, ಮುಖ್ಯ ರಿಟರ್ನ್ printfing ಇದೆ

1446
01:16:50,950 --> 01:16:52,830
foo, 4 ಮೌಲ್ಯವನ್ನು.

1447
01:16:52,830 --> 01:16:57,930
foo, ಕೇವಲ ಮರಳಲು ಹೋಗುತ್ತದೆ
ಬಾರ್ 4 ಅಲ್ಪವಿರಾಮ 6 ಮೌಲ್ಯವನ್ನು.

1448
01:16:57,930 --> 01:17:02,380
ಮತ್ತು ಬಾರ್ ಕೆಲವು ಸ್ಥಳೀಯ ಸೆಟ್ ಹೋಗುವ
4 ಬಾರಿ 6 ಸಮಾನವಾಗಿರುತ್ತದೆ ವೇರಿಯಬಲ್ ಎನ್.

1449
01:17:02,380 --> 01:17:03,920
ತದನಂತರ N ಹಿಂತಿರುಗಿ.

1450
01:17:03,920 --> 01:17:09,130
>> ಆದ್ದರಿಂದ ಉದ್ದಕ್ಕೂ ಸ್ಟಾಕ್ ನೋಡೋಣ
ಈ ಕಾರ್ಯಕ್ರಮದ ನಿಜವಾದ ಪುನರಾವರ್ತನೆ.

1451
01:17:09,130 --> 01:17:10,500
ಆದ್ದರಿಂದ ನಮ್ಮ ಸ್ಟಾಕ್ ಕೆಳಭಾಗದಲ್ಲಿ ಇಲ್ಲ.

1452
01:17:10,500 --> 01:17:12,620
ಸ್ಟಾಕ್ ಬೆಳೆಯುವ ನೆನಪಿಡಿ.

1453
01:17:12,620 --> 01:17:15,370
ನಮ್ಮ ಸ್ಟಾಕ್ ಕೆಳಭಾಗದಲ್ಲಿ, ನಾವು
ಮುಖ್ಯ ಒಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಹೊಂದಿವೆ.

1454
01:17:15,370 --> 01:17:17,000
ಯಾವಾಗ ಪ್ರಾರಂಭಗೊಳ್ಳುವ, ಮುಖ್ಯ
ಯಾವಾಗಲೂ ಏರಲಿದೆ

1455
01:17:17,000 --> 01:17:18,560
ನಮ್ಮ ಸ್ಟಾಕ್ ಕೆಳಭಾಗದಲ್ಲಿ.

1456
01:17:18,560 --> 01:17:20,880
>> ಮತ್ತು ಒಳಗೆ ಏನು ನಮ್ಮ
ಮುಖ್ಯ ಫಾರ್ ಫ್ರೇಮ್ ಸ್ಟಾಕ್?

1457
01:17:20,880 --> 01:17:23,810
ಅದಕ್ಕೆ ಸ್ಥಳೀಯ ಕೂಡಾ
ಮುಖ್ಯ ಅಸ್ಥಿರ ನಾನು ಮೊದಲೇ ಹೇಳಿದ, ಹಾಗೆ

1458
01:17:23,810 --> 01:17:29,670
ನಾವು argc ಮತ್ತು rgv ಸ್ಥಳವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಎಂದು
ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಒಳಗೆ.

1459
01:17:29,670 --> 01:17:33,260
ಈಗ ಹೋಗುತ್ತದೆ ಆದ್ದರಿಂದ ಮುಖ್ಯ
ಕಾರ್ಯ foo ​​ಕರೆ.

1460
01:17:33,260 --> 01:17:35,125
ಮತ್ತು foo, ಹೋಗುವ ಅಂದರೆ
ತನ್ನ ಸ್ವಂತ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಪಡೆಯಲು.

1461
01:17:35,125 --> 01:17:36,970
>> ಈಗ ನಾವು ಒಳಗೆ ಇದ್ದೇವೆ
ಕಾರ್ಯ foo.

1462
01:17:36,970 --> 01:17:38,610
ಮತ್ತು ಹೋಗಿ ಅಗತ್ಯವಿದೆ
foo ನ ಸ್ಟಾಕ್ ಫ್ರೇಮ್?

1463
01:17:38,610 --> 01:17:41,100
ಅಲ್ಲದೆ, foo, ವಾದವನ್ನು ಎನ್ ಹೊಂದಿದೆ.

1464
01:17:41,100 --> 01:17:45,440
ಆ ಇಲ್ಲಿದೆ ಕಾರಣ ಎನ್ 4 ಸಮಾನವಾಗಿರುತ್ತದೆ ಏನು
ಮುಖ್ಯ foo ​​ನ ಚರ್ಚೆಯಂತೆ ರವಾನಿಸುವುದು.

1465
01:17:45,440 --> 01:17:48,490
>> ಈಗ foo ಬಾರ್ ಕರೆಯಲು ಹೋಗುತ್ತದೆ.

1466
01:17:48,490 --> 01:17:52,070
ಏನು ಬಾರ್ ಒಳಗೆ ಮಾಡಲಿಕ್ಕೆ ಇದೆ
ಅದರ 'ಸ್ಟಾಕ್ ಫ್ರೇಮ್?

1467
01:17:52,070 --> 01:17:55,610
ಇದು ಆರು ಸಮಾನವಾಗಿರುತ್ತದೆ 4 ವೈ x = ಹೊಂದಿದೆ.

1468
01:17:55,610 --> 01:17:58,540
ನಾವು ಹೊಂದಿರುವ ನೀನು ಎಲ್ಲಾ ಅಲ್ಲ
ಬಾರ್ ಕಾರಣ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ

1469
01:17:58,540 --> 01:18:00,580
ಒಂದು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ N ಹೊಂದಿದೆ.

1470
01:18:00,580 --> 01:18:03,370
ಮತ್ತು N ನಾವು 24 ಸಮಾನವಾಗಿರುತ್ತದೆ ಸೆಟ್ ನೀನು.

1471
01:18:03,370 --> 01:18:05,750
>> ಈಗ ಬಾರ್ ಎನ್ ಮರಳಲು ಹೋಗುತ್ತದೆ.

1472
01:18:05,750 --> 01:18:09,300
ಆದ್ದರಿಂದ ಬಾರ್ 24 ಮರಳಲಿದ್ದಾರೆ
ಸ್ಟಾಕ್ ಫ್ರೇಮ್, foo.

1473
01:18:09,300 --> 01:18:12,560
ಮತ್ತು ಬಾರ್ ಈಗ, ಮರಳಲಿದ್ದಾರೆ ಕಾರಣ
ನಾವು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ರೀಲೋಡ್ ನೀವು ಅರ್ಥ

1474
01:18:12,560 --> 01:18:14,250
ಸ್ಟಾಕ್ ಆಫ್ ಬಾರ್.

1475
01:18:14,250 --> 01:18:18,430
ಬಾರ್ ಎಂದು ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಮೆಮೊರಿ
ಬಳಸಿ ಸ್ಟಾಕ್ ಈಗ.

1476
01:18:18,430 --> 01:18:21,550
>> ಈಗ, foo, ಸಹ ಹೋಗುತ್ತದೆ
ಮುಖ್ಯ 24 ಮರಳಲು.

1477
01:18:21,550 --> 01:18:25,470
ಈಗ ಆ foo, ಮೆಮೊರಿ ಮರಳಲಿದ್ದಾರೆ
ಆ foo ಅದರ 'ಬಳಸುತ್ತಿದ್ದರು

1478
01:18:25,470 --> 01:18:27,550
ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಹೋಗುತ್ತವೆ ಇದೆ.

1479
01:18:27,550 --> 01:18:29,660
ಈಗ, ಮುಖ್ಯ printf ಕರೆ ಹೋಗುತ್ತದೆ.

1480
01:18:29,660 --> 01:18:31,660
ಆದ್ದರಿಂದ printf ಮತ್ತೊಂದು ಕ್ರಿಯೆಯಾಗಿದೆ.

1481
01:18:31,660 --> 01:18:35,320
ನಾವು printf ಕರೆ ಮಾಡಿದಾಗ, ಇದು ಎಂದು ವಿಶೇಷವೇನು
printf ಮತ್ತೊಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್

1482
01:18:35,320 --> 01:18:36,470
ಕಾರ್ಯ ಕರೆ.

1483
01:18:36,470 --> 01:18:37,990
>> ಏನು ನಾವು printf ಸಾಗಿ?

1484
01:18:37,990 --> 01:18:40,090
ಆ ಹೋಗಲು ವಿಶೇಷವೇನು ಇಲ್ಲಿದೆ
ತನ್ನ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಮೇಲೆ.

1485
01:18:40,090 --> 01:18:44,970
ಅತಿ ಕನಿಷ್ಠ, ನಾವು ಹಾದುಹೋಗುವ ನೀವು
ಎಂದು ಶೇಕಡಾ ನಾನು ಎನ್ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಮತ್ತು

1486
01:18:44,970 --> 01:18:47,180
ವಾದವನ್ನು 24.

1487
01:18:47,180 --> 01:18:50,370
ಇದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಇಲ್ಲಿದೆ ರಲ್ಲಿ ಇದು ಹೆಚ್ಚು ಹೊಂದಿರಬಹುದು
printf ಕೆಲವು ಬಳಸುತ್ತಿರುವ ಉಂಟಾದರೆ

1488
01:18:50,370 --> 01:18:51,200
ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು.

1489
01:18:51,200 --> 01:18:51,920
ನಾವು ಗೊತ್ತಿಲ್ಲ.

1490
01:18:51,920 --> 01:18:53,810
>> ಆದರೆ ಎಲ್ಲಾ printf ಎಂದು ನ ಹೋಗುತ್ತದೆ
ಫ್ರೇಮ್ ಸ್ಟಾಕ್.

1491
01:18:53,810 --> 01:18:55,740
ಇದು printf ಕಾರ್ಯಗತಗೊಳಿಸಲು ವಿಶೇಷವೇನು.

1492
01:18:55,740 --> 01:18:56,830
ನಂತರ printf ನಿಲ್ಲಿಸುವುದಾಗಿ.

1493
01:18:56,830 --> 01:18:57,820
ಇದು ಹಿಂದಿರುಗುವ.

1494
01:18:57,820 --> 01:18:58,960
ಅಂತಿಮವಾಗಿ, ಪ್ರಮುಖ ಮಾಡಲಾಗುತ್ತದೆ.

1495
01:18:58,960 --> 01:18:59,860
ಮುಖ್ಯ ಹಿಂದಿರುಗುವ.

1496
01:18:59,860 --> 01:19:02,020
ತದನಂತರ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮಾಡಲಾಗುತ್ತದೆ.

1497
01:19:02,020 --> 01:19:02,480
ಹೌದು?

1498
01:19:02,480 --> 01:19:04,505
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ನೋಡುತ್ತಿದ್ದೀರಿ [ಕೇಳಿಸುವುದಿಲ್ಲ]

1499
01:19:04,505 --> 01:19:05,900
ವಾದಗಳು [ಕೇಳಿಸುವುದಿಲ್ಲ]

1500
01:19:05,900 --> 01:19:06,830
ನಿಯತಾಂಕಗಳನ್ನು?

1501
01:19:06,830 --> 01:19:09,970
>> ರಾಬ್: ಆದ್ದರಿಂದ ಒಂದು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸ ಇಲ್ಲ
ವಾದಗಳು ಮತ್ತು ನಿಯತಾಂಕಗಳನ್ನು ನಡುವೆ.

1502
01:19:09,970 --> 01:19:14,400
ಮತ್ತು ನಿಜವಾಗಿಯೂ, ಸಾಮಾನ್ಯ ಮಾತನಾಡಲು, ಜನರ ಒಲವು
ಸಾರ್ವಕಾಲಿಕ ಅವುಗಳನ್ನು ಬೆರೆಸುವ.

1503
01:19:14,400 --> 01:19:17,550
ಆದರೆ ನಿಯತಾಂಕಗಳನ್ನು ಫಾರ್ಮಲ್
ವಸ್ತುಗಳ ಹೆಸರನ್ನು.

1504
01:19:17,550 --> 01:19:20,180
>> ಆದ್ದರಿಂದ argc ಮತ್ತು argv
ಮುಖ್ಯ ನಿಯತಾಂಕಗಳನ್ನು.

1505
01:19:20,180 --> 01:19:23,440
ವಾದ ಏನು ವಾಸ್ತವವಾಗಿ ಇವೆ
ಆ ನಿಯತಾಂಕಗಳನ್ನು ಹಾದು.

1506
01:19:23,440 --> 01:19:28,340
ಆದ್ದರಿಂದ ನಾನು 4, foo, 4 ಕರೆ
ನಾನು ಹಾದುಹೋಗುವ ನಾನು ವಾದವು.

1507
01:19:28,340 --> 01:19:31,460
ಮತ್ತು ಒಳಗೆ ನಿಯತಾಂಕ ಎನ್,
foo,, ಕೆಳಗಿನ 4 ಪಡೆದಿರುತ್ತದೆ

1508
01:19:31,460 --> 01:19:32,880
4 ರಿಂದ ವಾದವನ್ನು ಆಗಿತ್ತು.

1509
01:19:32,880 --> 01:19:35,826
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1510
01:19:35,826 --> 01:19:37,880
>> ರಾಬ್: ಎನ್ ಬಾರ್ಗೆ ಒಂದು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್.

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
ಎನ್, ಇನ್ನೂ foo, ಸ್ಥಳೀಯ ಆದರೆ
ಅದರ foo ಒಂದು ನಿಯತಾಂಕ ಇಲ್ಲಿದೆ.

1513
01:19:44,960 --> 01:19:48,190
ಇದು ಒಂದು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಅಲ್ಲ.

1514
01:19:48,190 --> 01:19:48,546
ಹೌದು?

1515
01:19:48,546 --> 01:19:51,180
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1516
01:19:51,180 --> 01:19:55,400
>> ರಾಬ್: foo, ಕೇವಲ ಆಹ್ವಾನವಿದೆ ಬಾರ್ ಮತ್ತು
ಯಾವುದೇ ಬಾರ್ ಆದಾಯ ಹಿಂದಿರುಗಿದ.

1517
01:19:55,400 --> 01:19:56,786
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1518
01:19:56,786 --> 01:19:59,591
>> ರಾಬ್: ಹೌದು, ಕೇವಲ ಅನೇಕ ನೋಡಲು
ಚೌಕಟ್ಟುಗಳು ಬಣವೆ.

1519
01:19:59,591 --> 01:20:00,082
ಹೌದು?

1520
01:20:00,082 --> 01:20:03,519
>> ಪ್ರೇಕ್ಷಕರು: ವೈ foo ಎಂಬ ಮಾಡಲಾಯಿತು
printf ಮೊದಲು?

1521
01:20:03,519 --> 01:20:05,920
>> ರಾಬ್: ಏಕೆ, foo, printf ಮೊದಲು ಕರೆಯಲಾಯಿತು?

1522
01:20:05,920 --> 01:20:10,740
ನಾನು ತೋರಿಸಬಹುದಿತ್ತು ಆದ್ದರಿಂದ, ಬದಲಿಗೆ, ಕೆಲಸ
ಇಂಟ್ X 4 ಆಫ್ foo, ಸಮನಾಗಿರುತ್ತದೆ

1523
01:20:10,740 --> 01:20:12,980
ಮತ್ತು ಆಗ x ಮುದ್ರಿತ.

1524
01:20:12,980 --> 01:20:17,900
ಬದಲಿಗೆ, ನಾನು ಕಾರ್ಯ ಸೇರಿ
printf ವಾದದಲ್ಲಿ ಕರೆ.

1525
01:20:17,900 --> 01:20:23,670
>> ಆದರೆ ನಾವು ವಾಸ್ತವವಾಗಿ ಸಾಧ್ಯವಿಲ್ಲ
ನಾವು ರವರೆಗೆ printf ಕರೆ ಕಾರ್ಯಗತಗೊಳಿಸಿ

1526
01:20:23,670 --> 01:20:25,610
4 foo, ಏನು ಎಂಬುದನ್ನು ಅಂದಾಜು.

1527
01:20:25,610 --> 01:20:27,480
ಆದ್ದರಿಂದ ನಾವು ಈ ಮೌಲ್ಯಮಾಪನ ನೀನು.

1528
01:20:27,480 --> 01:20:32,504
ಮತ್ತು ಆ ಮಾಡಲಾಗುತ್ತದೆ ಒಮ್ಮೆ ಮಾತ್ರ ಹೋಗುವ
ಮತ್ತೆ ಬಂದು ಈ ಮೌಲ್ಯಮಾಪನ.

1529
01:20:32,504 --> 01:20:32,990
ಹೌದು?

1530
01:20:32,990 --> 01:20:37,364
>> ಪ್ರೇಕ್ಷಕರು: ಎರಡೂ ಬಾರ್ ರಿಂದ [ಕೇಳಿಸುವುದಿಲ್ಲ]

1531
01:20:37,364 --> 01:20:41,738
ಮೌಲ್ಯ, ಏಕೆ ನಾವು [ಕೇಳಿಸುವುದಿಲ್ಲ] ಹೊಂದಿಲ್ಲ?

1532
01:20:41,738 --> 01:20:44,400
>> ರಾಬ್: ಅವರು ಸಂಪೂರ್ಣವಾಗಿ ಇಂಟ್ ಇರಬೇಕು.

1533
01:20:44,400 --> 01:20:46,260
ಆ ಮೇಲೆ ಸೆಳೆಯಿತು ಇಲ್ಲ
ಅನೇಕ ಪಾಸ್ಗಳನ್ನು.

1534
01:20:46,260 --> 01:20:49,010
ಆದ್ದರಿಂದ ಇಂಟ್ ಬಾರ್ ಮತ್ತು ಇಂಟ್ ಇರಬೇಕು
ಆ ಎರಡೂ ರಿಂದ ಫೂ

1535
01:20:49,010 --> 01:20:50,460
ಪೂರ್ಣಾಂಕಗಳ ಹಿಂದಿರುಗುತ್ತಿದ್ದಾರೆ.

1536
01:20:50,460 --> 01:20:54,214
ಅವರು ಹೋಗುತ್ತಿಲ್ಲ ಶೂನ್ಯ ಮಾತ್ರವಲ್ಲ
ನೈಜ ಮೌಲ್ಯಗಳಿಗೆ ಮರಳಲು.

1537
01:20:54,214 --> 01:20:54,692
ಹೌದು?

1538
01:20:54,692 --> 01:20:58,038
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ಒಂದು ಸಾಲಿನ ಹೊಂದಿದ್ದರೆ ಮೇಲೆ
ರಿಟರ್ನ್, [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> ರಾಬ್: ರಿಟರ್ನ್ ಮೇಲೆ ಸಾಲು?

1541
01:21:03,730 --> 01:21:04,410
>> ಪ್ರೇಕ್ಷಕರು: ಹೌದು.

1542
01:21:04,410 --> 01:21:10,780
ಲೈಕ್ ನೀವು printf ಮತ್ತು [ಕೇಳಿಸುವುದಿಲ್ಲ] ಮಾಡಿದರೆ,
ಇದು ಎರಡು ಬಾರಿ ಮುದ್ರಣ ಎಂದು?

1543
01:21:10,780 --> 01:21:12,992
>> ರಾಬ್: foo, ಆದ್ದರಿಂದ ಒಳಗೆ?

1544
01:21:12,992 --> 01:21:15,945
ನಾವು ಇಲ್ಲಿ printf ಹೊಂದಿದ್ದರೆ?

1545
01:21:15,945 --> 01:21:16,750
>> ಪ್ರೇಕ್ಷಕರು: ಹೌದು.

1546
01:21:16,750 --> 01:21:19,510
>> ರಾಬ್: ಆದ್ದರಿಂದ ನಾವು printf ಹಕ್ಕನ್ನು
ಇಲ್ಲಿ, ಇದು ಒಮ್ಮೆ ಮುದ್ರಿಸಲು ಎಂದು.

1547
01:21:19,510 --> 01:21:23,400
ನಾವು ಒಮ್ಮೆ ಬಲ foo, ಕರೆಯುತ್ತಿರುವ ಕಾರಣ
ಇಲ್ಲಿ, ನಂತರ ನಾವು printf ಹಿಟ್ ಮಾಡುತ್ತೇವೆ.

1548
01:21:23,400 --> 01:21:24,620
ಆಗ ಬಾರ್ ಕರೆ ಮಾಡುತ್ತೇವೆ.

1549
01:21:24,620 --> 01:21:25,710
ತದನಂತರ foo ಹಿಂದಿರುಗುವ.

1550
01:21:25,710 --> 01:21:26,275
ಮತ್ತು ಅಷ್ಟೇ.

1551
01:21:26,275 --> 01:21:30,985
ನಾವು ಮಾತ್ರ ಎದುರಿಸುವ
ಒಮ್ಮೆ, printf.

1552
01:21:30,985 --> 01:21:31,482
ಹೌದು?

1553
01:21:31,482 --> 01:21:32,973
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]

1554
01:21:32,973 --> 01:21:37,950
ನಾವು ಮೊದಲ ಇರುವ ಕಾರಣ, printf, foo ಕರೆ
printf ಕರೆ ಮತ್ತು ನಂತರ ನಾವು ಹಾದುಹೋಗುವ ನೀವು

1555
01:21:37,950 --> 01:21:38,580
ವಾದಗಳು.

1556
01:21:38,580 --> 01:21:40,960
>> ರಾಬ್: ಆದ್ದರಿಂದ ಸಿದ್ಧಾಂತದಲ್ಲಿ, ಅಲ್ಲ
printf foo, ಕರೆ?

1557
01:21:40,960 --> 01:21:42,220
ಆದ್ದರಿಂದ ಯಾವುದೇ.

1558
01:21:42,220 --> 01:21:47,360
ಸಿ ಹೋಗುವ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಕೇವಲ ಸಲುವಾಗಿ
ನಾವು ಮೊದಲು, ಈ ವಿಷಯಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು

1559
01:21:47,360 --> 01:21:49,800
, ವಾದಗಳನ್ನು ಎಲ್ಲಾ ಕಾರ್ಯ ಕರೆ
ಕಾರ್ಯಕ್ಕೆ ಹೊಂದಿರುತ್ತವೆ

1560
01:21:49,800 --> 01:21:51,600
ಸಂಪೂರ್ಣವಾಗಿ ಮೌಲ್ಯಮಾಪನ.

1561
01:21:51,600 --> 01:21:53,540
ಆದ್ದರಿಂದ ಈ ಸಂಪೂರ್ಣವಾಗಿ ಮೌಲ್ಯಮಾಪನ?

1562
01:21:53,540 --> 01:21:54,610
ಹೌದು, ಇದು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನ.

1563
01:21:54,610 --> 01:21:55,480
ಇದು ಮೌಲ್ಯವನ್ನು.

1564
01:21:55,480 --> 01:21:57,200
>> ನಂತರ ನಾವು ಸಂಪೂರ್ಣವಾಗಿ ಮಾಡಬೇಕು
ಈ ಮೌಲ್ಯಮಾಪನ.

1565
01:21:57,200 --> 01:21:59,720
ಈಗ ಎಲ್ಲಾ, ಒಮ್ಮೆ ಮಾಡಲಾಗುತ್ತದೆ
ತಮ್ಮ ವಾದವನ್ನು ತಪಾಸಿಸಲಾಗುತ್ತದೆ.

1566
01:21:59,720 --> 01:22:01,982
ಮತ್ತು ಈಗ ನಾವು ಮಾಡಬಹುದು
printf ಕರೆ.

1567
01:22:01,982 --> 01:22:02,478
ಹೌದು?

1568
01:22:02,478 --> 01:22:03,966
>> ಪ್ರೇಕ್ಷಕರು: ಒಂದು ಪ್ರಶ್ನೆ.

1569
01:22:03,966 --> 01:22:06,942
ನೀವು ಶೂನ್ಯವನ್ನು ಕಾರ್ಯ ಹೊಂದಿದ್ದರೆ, ಮಾಡಬೇಕಾಗುತ್ತದೆ
ನೀವು ರಿಟರ್ನ್ ಅರ್ಧವಿರಾಮ ಹೊಂದಿವೆ?

1570
01:22:06,942 --> 01:22:09,910
>> ರಾಬ್: ನೀವು ಮರಳುವುದನ್ನು ಅರ್ಧವಿರಾಮ ಇಲ್ಲ
ನೀವು ಶೂನ್ಯವನ್ನು ಕಾರ್ಯ ಹೊಂದಿದ್ದರೆ.

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
ಸರಿ.

1573
01:22:14,780 --> 01:22:15,830
ಈಗ ಕೆಲವು ರಾಶಿ ಸ್ಟಫ್.

1574
01:22:15,830 --> 01:22:19,640
ರಾಶಿ ನಾವು ವ್ಯವಹರಿಸಲು ನೀನು ಹೇಗೆ
ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ನಿರ್ವಹಣೆ.

1575
01:22:19,640 --> 01:22:23,100
ಈ ನೇರವಾಗಿ ವ್ಯತಿರಿಕ್ತವಾಗಿ
ನಾವು ಸ್ವಯಂಚಾಲಿತ ಕರೆನೀಡುವ ಸ್ಟಾಕ್

1576
01:22:23,100 --> 01:22:24,100
ಸ್ಮರಣೆ ನಿರ್ವಹಣೆ.

1577
01:22:24,100 --> 01:22:27,140
>> ಸ್ಟಾಕ್ ಮೇಲೆ ಆದ್ದರಿಂದ, ನೀವು ನಿಜವಾಗಿಯೂ ಎಂದಿಗೂ
ಹೇಗೆ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ವ್ಯವಹರಿಸಲು

1578
01:22:27,140 --> 01:22:30,400
ತಳ್ಳಿ ಎಲ್ಲಾ ಆಫ್ ಬೇರ್ಪಡಿಸಿದ ಮಾಡಲಾಗುತ್ತಿದೆ
ಈ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಮತ್ತು ಎಲ್ಲಾ ಸಂಗತಿಗಳನ್ನು.

1579
01:22:30,400 --> 01:22:31,070
ನೀವು ಅದರ ಬಗ್ಗೆ ಚಿಂತೆ ಇಲ್ಲ.

1580
01:22:31,070 --> 01:22:32,070
ಇದು ಸ್ವಯಂಚಾಲಿತ ಇಲ್ಲಿದೆ.

1581
01:22:32,070 --> 01:22:36,990
ರಾಶಿ ಕೈಪಿಡಿ.

1582
01:22:36,990 --> 01:22:38,070
ಮತ್ತು [ಕೇಳಿಸುವುದಿಲ್ಲ]

1583
01:22:38,070 --> 01:22:41,260
ಈ ಕಾರ್ಯಗಳನ್ನು ಬರುತ್ತದೆ
malloc ಮತ್ತು ಉಚಿತ.

1584
01:22:41,260 --> 01:22:43,550
>> ಇಲ್ಲಿ ಇನ್ನೊಂದು ಕಾರ್ಯಕ್ರಮದ.

1585
01:22:43,550 --> 01:22:47,145
ನಾವು ಮಾಡುತ್ತಿರುವುದು ಎಲ್ಲಾ mallocing ಆಗಿದೆ
ಒಂದು ಪೂರ್ಣಾಂಕ.

1586
01:22:47,145 --> 01:22:49,360
ನಾವು ಸ್ಟಾರ್ X ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು ನೀವು.

1587
01:22:49,360 --> 01:22:52,520
ಸಹಜವಾಗಿ, ನಾವು ಪರಿಶೀಲಿಸಿ ಮಾಡಬೇಕು
ಎಕ್ಸ್ ಶೂನ್ಯ ವೇಳೆ ನೋಡಲು.

1588
01:22:52,520 --> 01:22:56,400
ನಂತರ ನಾವು ಏನು ಹೊರಟಿರುವೆ
ಎಕ್ಸ್ 50 ಸೂಚಿಸಲ್ಪಡುತ್ತದೆ.

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
, ತೋರುತ್ತಿರುವಂತೆ ಎಂಬುದನ್ನು ಎಕ್ಸ್ ಮುದ್ರಿಸಿ
ಮುದ್ರಣ X, ಮತ್ತು ನಂತರ ಉಚಿತ ಎಕ್ಸ್.

1591
01:23:03,260 --> 01:23:08,920
>> ಆದ್ದರಿಂದ ಹೇಗೆ ಈ ವಾಸ್ತವವಾಗಿ ನೋಡಲು ಹೋಗುತ್ತದೆ
ನಾವು ನಮ್ಮ ಸ್ಟ್ಯಾಕ್ ಮತ್ತು ಹೀಪ್ ನೋಡಿದರೆ?

1592
01:23:08,920 --> 01:23:10,950
ನಾವು ಮತ್ತೆ ಪ್ರಾರಂಭಿಸಿ.

1593
01:23:10,950 --> 01:23:12,580
ಮೊದಲು ನಮ್ಮ ಸ್ಟಾಕ್ ಕೆಳಭಾಗದಲ್ಲಿ.

1594
01:23:12,580 --> 01:23:15,930
ನಿನ್ನ ನೇರವಾಗಿ ರಾಶಿ ನೆನಪಿಡಿ
ಸ್ಟಾಕ್ ವಿರೋಧಿಸುತ್ತದೆ?

1595
01:23:15,930 --> 01:23:18,850
ನಾವು ಹೊಂದಿರುವ ನೀನು
ಅಲ್ಲಿ ನಮ್ಮ ರಾಶಿ ಮೇಲೆ.

1596
01:23:18,850 --> 01:23:22,590
>> ನಮ್ಮ ಸ್ಟಾಕ್ ಕೆಳಭಾಗದಲ್ಲಿ ಆದ್ದರಿಂದ, ನಾವು
ಮುಖ್ಯ ನಮ್ಮ ಸ್ಟಾಕ್ ಫ್ರೇಮ್.

1597
01:23:22,590 --> 01:23:28,000
ಇದು argc, argv ಜಾಗವನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ನಾವು
ಈಗ ಸ್ಥಳೀಯ ವ್ಯತ್ಯಯ X, ಹೊಂದಿರುವ

1598
01:23:28,000 --> 01:23:30,030
ಒಂದು ಇಂಟ್ ನಟ.

1599
01:23:30,030 --> 01:23:32,240
ನಾವು ತಿರುಗಿ ಎಂದು ನೀನು
ಈ ಕಾರ್ಯಕ್ರಮದ ಮೂಲಕ.

1600
01:23:32,240 --> 01:23:34,420
ನಾವು ಮೊದಲ ವಿಷಯ
malloc ಗೆ ಕರೆ.

1601
01:23:34,420 --> 01:23:36,250
>> ನಾವು malloc ಗೆ ಕರೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

1602
01:23:36,250 --> 01:23:37,100
Malloc ಕ್ರಿಯೆಯಾಗಿದೆ.

1603
01:23:37,100 --> 01:23:38,770
ಇದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಪಡೆಯಲು ವಿಶೇಷವೇನು.

1604
01:23:38,770 --> 01:23:40,180
ನಾವು malloc ಎಂದು ಸಾಗಿ?

1605
01:23:40,180 --> 01:23:41,610
ಆ ಒಳಗೆ ಹೋಗಲು ವಿಶೇಷವೇನು
ಸ್ಟಾಕ್ ಫ್ರೇಮ್.

1606
01:23:41,610 --> 01:23:45,130
ನಾವು 4 ಇದು ಎನ್, ಗಾತ್ರ ಸಾಗುವ.

1607
01:23:45,130 --> 01:23:49,700
ಆದ್ದರಿಂದ malloc ಗೆ ರವಾನಿಸಲಾಗಿದೆ.

1608
01:23:49,700 --> 01:23:50,910
>> , Malloc ಏನು ಮಾಡುತ್ತದೆ?

1609
01:23:50,910 --> 01:23:53,820
ಇದು ನಮಗೆ ರಾಶಿ ಮೇಲೆ ಕೆಲವು ಜಾಗವನ್ನು ಹಿಡಿಯುತ್ತಾನೆ.

1610
01:23:53,820 --> 01:23:55,320
ನಾವು ರಾಶಿ ಹೋಗಲು ನೀನು.

1611
01:23:55,320 --> 01:23:57,990
ನಾವು ದೋಚಿದ ನೀನು
ರಾಶಿ 4 ಬೈಟ್ಗಳು.

1612
01:23:57,990 --> 01:24:01,500
ಇದರಿಂದ ಕೇವಲ ನೀಡುತ್ತವೆ
ಅನಿಯಂತ್ರಿತ ವಿಳಾಸ.

1613
01:24:01,500 --> 01:24:06,680
0x123 ಕೇವಲ ಒಂದು ನಟಿಸುವುದು
ರಾಶಿ ಎಂದು ವಿಳಾಸ.

1614
01:24:06,680 --> 01:24:12,300
>> ಆದ್ದರಿಂದ ಒಳಗೆ ವಾಸ್ತವವಾಗಿ ಏನು
ವಿಳಾಸ ox123 ನಲ್ಲಿ ಮೆಮೊರಿ ಪ್ರದೇಶದಲ್ಲಿ?

1615
01:24:12,300 --> 01:24:13,080
ಕಸ.

1616
01:24:13,080 --> 01:24:15,270
ಆದ್ದರಿಂದ ನಾವು ಏನು ಸಂಗ್ರಹಿಸಿದ ಮಾಡಿಲ್ಲ.

1617
01:24:15,270 --> 01:24:18,830
ಆದ್ದರಿಂದ ದೂರದ ನಾವು, ತಿಳಿದಂತೆ
ಏನು ಎಂದು.

1618
01:24:18,830 --> 01:24:20,560
ನೀವು ಶೂನ್ಯ ಇಲ್ಲಿದೆ ಕಲ್ಪಿಸಬಾರದು.

1619
01:24:20,560 --> 01:24:23,870
ಇದು ಅಲ್ಲ ಶೂನ್ಯ ಹೆಚ್ಚಿನ ಸಾಧ್ಯತೆ.

1620
01:24:23,870 --> 01:24:26,260
>> ಈಗ, malloc ರಿಟರ್ನ್ಸ್.

1621
01:24:26,260 --> 01:24:28,020
ನಾವು ಆಗ, malloc ಆದಾಯ ಏನು ಮಾಡಬೇಕು?

1622
01:24:28,020 --> 01:24:29,800
ನಾವು ಇದಕ್ಕೆ ಯಾವ ಸೆಟ್.

1623
01:24:29,800 --> 01:24:32,290
ನಾವು x = ಸೆಟ್ ಏನು
ಇದು ಮರಳಲಿದ್ದಾರೆ.

1624
01:24:32,290 --> 01:24:33,690
ಹಾಗಾಗಿ ಇದು ಮರಳಲಿದ್ದಾರೆ?

1625
01:24:33,690 --> 01:24:38,150
ಎಂದು ಏಕೆಂದರೆ ಇದು 0x123 ಮರಳಿ
ಮೆಮೊರಿ ಬ್ಲಾಕ್ನ ವಿಳಾಸಕ್ಕೆ ಇದು ಆ

1626
01:24:38,150 --> 01:24:40,850
ಕೇವಲ ಹೇರಳ ಹಂಚಿಕೆ.

1627
01:24:40,850 --> 01:24:47,160
>> ಆದ್ದರಿಂದ 0x123 X ಈಗ ಸೆಟ್ ಏರಲಿದೆ ಮರಳಬಹುದು
0x123 ಸಮಾನವಾಗಿರುತ್ತದೆ ಇದು ಸಚಿತ್ರವಾಗಿ,

1628
01:24:47,160 --> 01:24:52,940
ನಾವು ಆಗಾಗ ನಿಜವಾದ ಹೊಂದಿರುವ ಎಕ್ಸ್ ಸೆಳೆಯುತ್ತವೆ
ಎಂದು ಬ್ಲಾಕ್ ತೋರುತ್ತಿರುವಂತೆ ಬಾಣದ.

1629
01:24:52,940 --> 01:24:55,820
ಆದರೆ ಎಕ್ಸ್ ಕೇವಲ ವಿಳಾಸಕ್ಕೆ ಉಳಿಸುವುದು.

1630
01:24:55,820 --> 01:24:58,670
ಈಗ ನಾವು X ಶೂನ್ಯ ವೇಳೆ, ಪರಿಶೀಲಿಸಿ ಮಾಡಬೇಕು.

1631
01:24:58,670 --> 01:24:59,120
ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಅಲ್ಲ.

1632
01:24:59,120 --> 01:25:02,170
ನಾವು, malloc ಸಫಲಗೊಂಡ ನಟಿಸುವುದು.

1633
01:25:02,170 --> 01:25:04,950
>> ಈಗ ಸ್ಟಾರ್ X 50 ಸಮನಾಗಿರುತ್ತದೆ.

1634
01:25:04,950 --> 01:25:08,450
ಆದ್ದರಿಂದ ಸ್ಟಾರ್ ಅರ್ಥ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ
ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ.

1635
01:25:08,450 --> 01:25:12,700
ಆದ್ದರಿಂದ 0x123 ನಾವು ನೀನು
ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ.

1636
01:25:12,700 --> 01:25:14,660
ಆದ್ದರಿಂದ ಅಲ್ಲಿ ನಮಗೆ ತೆರೆದಿಡುತ್ತದೆ.

1637
01:25:14,660 --> 01:25:16,310
ನಾವು ಆ ವಿಳಾಸದಲ್ಲಿ ಏನು ಮಾಡುತ್ತಿದ್ದಾರೆ?

1638
01:25:16,310 --> 01:25:19,020
ನಾವು 50 ಸಂಗ್ರಹಿಸಲು ನೀವು.

1639
01:25:19,020 --> 01:25:22,500
>> ಆದ್ದರಿಂದ ಈ ಸಾಲಿನ ನಂತರ, ಏನು
ವಿಷಯಗಳನ್ನು ರೀತಿ ಹೋಗುವ.

1640
01:25:22,500 --> 01:25:24,640
ಈಗ ಇದು ಇನ್ನು ಮುಂದೆ
ಅಲ್ಲಿ ಕಸ.

1641
01:25:24,640 --> 01:25:28,910
ಈಗ ನಾವು 50 ಎಂದು ಎಂದು ತಿಳಿಯಲು
ನಿರ್ದಿಷ್ಟ ವಿಳಾಸಕ್ಕೆ ಕಾರಣ

1642
01:25:28,910 --> 01:25:32,410
ನಾವು ಹೊಂದಿಸಿ.

1643
01:25:32,410 --> 01:25:32,790
ಸರಿ?

1644
01:25:32,790 --> 01:25:34,370
ಈಗ ನಾವು F ಮುದ್ರಿಸಲು ನೀನು.

1645
01:25:34,370 --> 01:25:38,490
>> ಆದ್ದರಿಂದ ಮೊದಲ ನಾವು ಸ್ಟಾರ್ X ಮುದ್ರಿಸಲು ನೀನು.

1646
01:25:38,490 --> 01:25:39,640
ಆದ್ದರಿಂದ ಸ್ಟಾರ್ X ಏನು?

1647
01:25:39,640 --> 01:25:44,300
ಮತ್ತೆ, ಸ್ಟಾರ್ X ಹೋಗಿ ಅರ್ಥ
X ತೋರುತ್ತಿರುವಂತೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ವಿಷಯ.

1648
01:25:44,300 --> 01:25:47,140
ಆದ್ದರಿಂದ X ಆ 0x123 ಗೋ ಉಳಿಸುವುದು.

1649
01:25:47,140 --> 01:25:48,490
ನಾವು 50 ಪಡೆಯಲು.

1650
01:25:48,490 --> 01:25:50,540
ಆದ್ದರಿಂದ F ಮುದ್ರಿಸಲು.

1651
01:25:50,540 --> 01:25:54,900
ಮತ್ತು ಇದು 50 ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು ಅರ್ಥ.

1652
01:25:54,900 --> 01:25:56,850
ತದನಂತರ ಮರಳಿಸುವ.

1653
01:25:56,850 --> 01:25:58,340
>> ನಂತರ ನಾವು ಎರಡನೇ printf ಹೊಂದಿವೆ.

1654
01:25:58,340 --> 01:25:59,370
ನಾವು ಈಗ ಶೇಕಡಾ ಪು ಆರ್.

1655
01:25:59,370 --> 01:26:01,680
ನೀವು ನೋಡಿಲ್ಲ, ಆ ಇಲ್ಲಿದೆ
ಕೇವಲ ನೀವು ಒಂದು ಪಾಯಿಂಟರ್ ಮುದ್ರಿಸಲು ಹೇಗೆ.

1656
01:26:01,680 --> 01:26:04,960
ನಾವು, ಶೇ ನಾನು ಹೊಂದಿವೆ
ಎಫ್, ಮತ್ತು ಈಗಾಗಲೇ ಆ ಎಲ್ಲಾ.

1657
01:26:04,960 --> 01:26:07,160
ಆದ್ದರಿಂದ ಶೇಕಡಾ ಪು, ಪಾಯಿಂಟರ್ ಮುದ್ರಿಸಲು.

1658
01:26:07,160 --> 01:26:08,920
>> ಆದ್ದರಿಂದ X ಸೂಚಿಯಾಗಿದೆ.

1659
01:26:08,920 --> 01:26:13,440
ನಾವು X ಸ್ವತಃ ಮುದ್ರಿಸಲು ನೀನು ವೇಳೆ,
ನಾವು ಒಳಗೆ ವಾಸ್ತವವಾಗಿ ಮುದ್ರಿಸುವ

1660
01:26:13,440 --> 01:26:19,220
ಆದ್ದರಿಂದ ಮೊದಲ 0x123 ಇದು X,
ಮುದ್ರಣ F 50 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ.

1661
01:26:19,220 --> 01:26:23,620
ಎರಡನೇ ಮುದ್ರಣ F ಹೋಗುತ್ತದೆ
ಹೌದು 0x123 ಮುದ್ರಿಸಲು?

1662
01:26:23,620 --> 01:26:27,460
>> ಪ್ರೇಕ್ಷಕರು: ನೀವು ರಷ್ಟು ಬಳಸುತ್ತೀರಾ
X ಸೂಚಿಯಾಗಿದೆ ಮುದ್ರಿಸಲು?

1663
01:26:27,460 --> 01:26:31,200
>> ರಾಬ್: ಆದ್ದರಿಂದ ನೀವು ರಷ್ಟು ಬಳಸುವುದು
X ಸೂಚಿಯಾಗಿದೆ ಮುದ್ರಿಸಲು?

1664
01:26:31,200 --> 01:26:38,350
ಆದ್ದರಿಂದ, ನೀವು ಆದರೆ ಶೇಕಡಾ X ಕೇವಲ ಆಗಿದೆ
ಸಾಮಾನ್ಯವಾಗಿ, ಹಾಗೆ ನೀವು ಕೆಲವು ಹೊಂದಿದ್ದರೆ

1665
01:26:38,350 --> 01:26:40,325
ಪೂರ್ಣಾಂಕ ಮತ್ತು ನೀವು ಮುದ್ರಿಸಲು ಬಯಸುವ
ಇದು ಒಂದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಮಾಹಿತಿ.

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
ನೀವು ಹಾಗೆ ಕೇವಲ ಹೇಗೆ.

1668
01:26:44,880 --> 01:26:47,160
>> ಆದರೆ, ಶೇಕಡಾ ಡಿ ಎಂದು
ದಶಮಾಂಶ ಮುದ್ರಿಸಲು.

1669
01:26:47,160 --> 01:26:50,310
ನಾವು ಪ್ರತಿಶತ ಎಂದು ಇಲ್ಲಿದೆ
ಡಿ. ನಾನು ಪೂರ್ಣಾಂಕ.

1670
01:26:50,310 --> 01:26:52,690
ಶೇಕಡಾ ಪು ವಿಶೇಷವಾಗಿ ಆಗಿದೆ
ಅಂಕಗಳಿಂದ.

1671
01:26:52,690 --> 01:26:54,060
>> ಆದ್ದರಿಂದ X ಸೂಚಿಯಾಗಿದೆ.

1672
01:26:54,060 --> 01:26:56,360
ನಾವು ಶೇಕಡಾ ಪು ಬಳಸಲು ಬಯಸುವ.

1673
01:26:56,360 --> 01:26:57,937
ಆದರೆ ಶೇಕಡಾ ಎಕ್ಸ್ ಸಹಾಯಕವಾಗಿತ್ತು.

1674
01:26:57,937 --> 01:26:58,414
ಹೌದು?

1675
01:26:58,414 --> 01:26:59,664
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> ರಾಬ್: ಹೌದು.

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
ಇದಕ್ಕೆ ಕನಿಷ್ಠ ಆದ್ದರಿಂದ ಕರೆಯುವ ನಾನು
ಇಲ್ಲಿ ರಲ್ಲಿ ಒಳಗೊಂಡಿರಲಿಲ್ಲ.

1680
01:27:13,440 --> 01:27:19,850
ಆದರೆ ಈ ಎರಡು ಚರ್ಚೆಗಳು ಅಗತ್ಯವಾಗಿ ಇವೆ
ಈ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನ ಒಳಗೆ

1681
01:27:19,850 --> 01:27:23,040
ಯಾವುದೇ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಜೊತೆಗೆ
printf ಬಳಸಿಕೊಂಡು ನಡೆಯುತ್ತದೆ.

1682
01:27:23,040 --> 01:27:27,020
ನಂತರ ಮುಂದಿನ ಕರೆ ಈಗ printf ಗೆ
printf ಒಳಗೆ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಆಗಿದೆ

1683
01:27:27,020 --> 01:27:33,960
ಶೇಕಡಾ ಪು ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್ ಎನ್ ಏನೇ
x ಮೌಲ್ಯವು 0x123 ಇದು ಹೊಂದಿದೆ.

1684
01:27:33,960 --> 01:27:34,425
ಹೌದು?

1685
01:27:34,425 --> 01:27:35,675
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> ರಾಬ್: ಇದು ಏನೋ ಮುದ್ರಿಸಲು ಮಾಡುತ್ತೇವೆ
ಈ ತೋರುತ್ತಿದೆ.

1688
01:27:40,880 --> 01:27:41,846
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1689
01:27:41,846 --> 01:27:44,510
>> ರಾಬ್: ಹಾಗಾಗಿ ವಿಳಾಸ ರೂಪದಲ್ಲಿ ಮುದ್ರಿಸುತ್ತದೆ.

1690
01:27:44,510 --> 01:27:47,003
ಇದು ವಿಳಾಸಕ್ಕೆ ತೋರುತ್ತಿದೆ.

1691
01:27:47,003 --> 01:27:47,494
ಹೌದು?

1692
01:27:47,494 --> 01:27:49,458
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1693
01:27:49,458 --> 01:27:51,075
>> ರಾಬ್: ಏಕೆ ಏನು?

1694
01:27:51,075 --> 01:27:52,920
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1695
01:27:52,920 --> 01:27:55,240
>> ರಾಬ್: ಏಕೆ ಈ ಪಾಯಿಂಟರ್ 4 ಬೈಟ್ಗಳು?

1696
01:27:55,240 --> 01:27:58,500
ಆದ್ದರಿಂದ ಇಡೀ ಗುಂಪೇ ಇವೆ
ಈ ಮುಂದೆ 0 ನ.

1697
01:27:58,500 --> 01:28:03,740
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ 0x0000000123 ಇಲ್ಲಿದೆ.

1698
01:28:03,740 --> 01:28:06,510
ಒಂದು 64 ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಇರುವುದಿಲ್ಲ
ಹೆಚ್ಚು ಸೊನ್ನೆಗಳು ಇಡೀ ಗುಂಪೇ.

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
ಹೌದು?

1701
01:28:11,900 --> 01:28:13,150
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> ರಾಬ್: ಮೊದಲ, printf
print-- ಹೋಗುತ್ತದೆ

1704
01:28:21,130 --> 01:28:21,980
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ].

1705
01:28:21,980 --> 01:28:24,420
>> ರಾಬ್: ಹೌದು, ಇದು ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು
ಯಾವ X ತೋರುತ್ತಿರುವಂತೆ ಇದೆ.

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
ಸ್ಟಾರ್ ಈ ಯಾವ ಹೇಳುತ್ತಾರೆ
ವಿಷಯ ಸೂಚಿಸುತ್ತಿದ್ದರು.

1708
01:28:29,070 --> 01:28:30,300
ಇದು ಪಡೆದುಕೊಳ್ಳಿ.

1709
01:28:30,300 --> 01:28:31,455
ಆದ್ದರಿಂದ ತೋರುತ್ತಿರುವಂತೆ ಎಂಬುದನ್ನು?

1710
01:28:31,455 --> 01:28:31,850
50.

1711
01:28:31,850 --> 01:28:32,410
ಇದು ಪಡೆದುಕೊಳ್ಳಿ.

1712
01:28:32,410 --> 01:28:33,390
ನಾವು ಮುದ್ರಿಸಲು ನೀನು ಇಲ್ಲಿದೆ.

1713
01:28:33,390 --> 01:28:37,020
ಮುಂದಿನ ಒಂದು, ಆದರೆ, ನಾವು ನೀವು
ಕೇವಲ ಸ್ವತಃ X ಮುದ್ರಣ.

1714
01:28:37,020 --> 01:28:38,850
ಎಫ್ ಒಳಗೆ ಏನು?

1715
01:28:38,850 --> 01:28:43,710
0x123.

1716
01:28:43,710 --> 01:28:44,500
ಸರಿ.

1717
01:28:44,500 --> 01:28:46,620
>> ನಂತರ, ಅಂತಿಮವಾಗಿ, ನಾವು ಉಚಿತ ಹೊಂದಿವೆ.

1718
01:28:46,620 --> 01:28:48,040
ನಾವು ಮುಕ್ತಗೊಳಿಸಲು ಸಾಗಿ?

1719
01:28:48,040 --> 01:28:49,470
ನಾವು X ಸಾಗುವ.

1720
01:28:49,470 --> 01:28:52,380
ನಾನು ವಾಸ್ತವವಾಗಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಆ
ಇದು ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ.

1721
01:28:52,380 --> 01:28:56,370
>> ನಾವು ಮೌಲ್ಯವನ್ನು ಸಾಗುವ
0x123 ಮುಕ್ತಗೊಳಿಸಲು.

1722
01:28:56,370 --> 01:28:59,070
ಈಗ ತಿಳಿದಿರುವ ಉಚಿತ, ಸರಿ,
ನಾನು ರಾಶಿ ಹೋಗುತ್ತಾರೆ ಹೊಂದಿವೆ

1723
01:28:59,070 --> 01:29:00,050
ಮತ್ತು ಮೆಮೊರಿ ಮುಕ್ತ.

1724
01:29:00,050 --> 01:29:03,920
ಇದು ಇನ್ನು ಮುಂದೆ ಬಳಸಿಕೊಂಡು ಏನನ್ನು
ವಿಳಾಸ 0x123 ನಲ್ಲಿ.

1725
01:29:03,920 --> 01:29:07,010
>> ಆದ್ದರಿಂದ ಉಚಿತ ಬಿಡುಗಡೆ ನಾನು
ರಾಶಿ ಎಂದು.

1726
01:29:07,010 --> 01:29:09,490
ಈಗ ನಮ್ಮ ರಾಶಿ ಮತ್ತೆ ಖಾಲಿಯಾಗಿದೆ.

1727
01:29:09,490 --> 01:29:11,120
ನಾವು ಯಾವುದೇ ಮೆಮೊರಿ ಸೋರುವಿಕೆ.

1728
01:29:11,120 --> 01:29:12,940
ಈಗ ಉಚಿತ ಹಿಂದಿರುಗುವ.

1729
01:29:12,940 --> 01:29:16,130
ಆ X ಇನ್ನೂ 0x123 ಗಮನಿಸಿ.

1730
01:29:16,130 --> 01:29:18,240
ಆದರೆ ಈಗ ಮಾನ್ಯ ಮೆಮೊರಿ ಅಲ್ಲ.

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
ನಾವು ಇನ್ನು ಮುಂದೆ, dereference ಎಕ್ಸ್ ಮಾಡಬೇಕು.

1733
01:29:23,986 --> 01:29:24,440
ಹೌದು?

1734
01:29:24,440 --> 01:29:27,240
>> ಪ್ರೇಕ್ಷಕರು: 0 ಅಧಿಕ ಮರಳುವುದು?

1735
01:29:27,240 --> 01:29:28,290
>> ರಾಬ್: 0 ಅಧಿಕ returen ಇದೆ?

1736
01:29:28,290 --> 01:29:31,110
ಹೌದು.

1737
01:29:31,110 --> 01:29:33,950
ನಾವು ಅಲ್ಲಿ ಏಕೆಂದರೆ ಪುಟ್
ನಾವು ಗಾಳಿಯಲ್ಲಿ ಒಂದು ರಿಟರ್ನ್ ಒಂದು ಹೊಂದಿವೆ.

1738
01:29:33,950 --> 01:29:36,830
ಆದ್ದರಿಂದ ಹೌದು, ಅನುಮತಿಸುತ್ತದೆ, ಹೀಗಿದೆ
ರಿಟರ್ನ್ 0 ಸೇರಿವೆ.

1739
01:29:36,830 --> 01:29:37,310
ಹೌದು?

1740
01:29:37,310 --> 01:29:38,560
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> ರಾಬ್: ಉಚಿತ ಎಕ್ಸ್ ನಂತರ, ಏನು ಸಂಭವಿಸುತ್ತದೆ
ನಾವು ಪಾಯಿಂಟರ್ dereference ಪ್ರಯತ್ನಿಸಿ?

1743
01:29:45,580 --> 01:29:47,240
ಇದು ಏನೂ ತಪ್ಪಾದಲ್ಲಿ ಸಾಧ್ಯತೆಯೂ ಇರುತ್ತದೆ.

1744
01:29:47,240 --> 01:29:49,330
ನಾವು ಇನ್ನೂ 50 ಪಡೆಯುತ್ತೀರಿ ಸಾಧ್ಯತೆಯಿದೆ.

1745
01:29:49,330 --> 01:29:53,590
>> ಅದು ನೆನಪಾಗಿ, ಸಹ, ಸಾಧ್ಯತೆಯೂ
ಈಗ ಯಾವುದೋ ಬಳಸಲಾಗುತ್ತಿದೆ.

1746
01:29:53,590 --> 01:29:57,140
ಆದ್ದರಿಂದ ಅದು ಸ್ಪಷ್ಟೀಕರಿಸದ ವರ್ತನೆಯನ್ನು ಇಲ್ಲಿದೆ.

1747
01:29:57,140 --> 01:30:00,772
ಮತ್ತು ಸ್ಪಷ್ಟೀಕರಿಸದ ಏನು ಅರ್ಥ
ಸಂಭವಿಸಬಹುದು.

1748
01:30:00,772 --> 01:30:01,250
ಹೌದು?

1749
01:30:01,250 --> 01:30:02,500
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> ರಾಬ್: ಇಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ನಿಗದಿಪಡಿಸುತ್ತದೆ
ಯಾವುದೋ ಎಕ್ಸ್.

1752
01:30:10,830 --> 01:30:15,870
ಇಲ್ಲಿಯೇ ನಾವು X ಸಮನಾಗಿರುತ್ತದೆ ಹೇಳಿದರು
malloc ಏನೋ ಬೇರೆ

1753
01:30:15,870 --> 01:30:17,100
malloc ಗಾತ್ರ ಈವೆಂಟ್

1754
01:30:17,100 --> 01:30:20,180
ನಂತರ ಮೂಲ ಬ್ಲಾಕ್
ಮೆಮೊರಿ ಬಿಡುಗಡೆ ಇಲ್ಲ.

1755
01:30:20,180 --> 01:30:21,490
ನಾವು ಅಧಿಕೃತವಾಗಿ ಕಳೆದುಕೊಂಡಿದ್ದಾರೆ.

1756
01:30:21,490 --> 01:30:23,150
ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಆಗಿದೆ.

1757
01:30:23,150 --> 01:30:25,090
ನಾವು ಎಲ್ಲಾ ಉಲ್ಲೇಖಗಳು ಕಳೆದುಕೊಂಡ ಬಂದಿದೆ
ಮೆಮೊರಿ ಬ್ಲಾಕ್ ಗೆ.

1758
01:30:25,090 --> 01:30:26,827
ಆದ್ದರಿಂದ ನಾವು ಮುಕ್ತಗೊಳಿಸಲು ಯಾವುದೇ ದಾರಿ ಇಲ್ಲ.

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
ಸರಿ, ಆದ್ದರಿಂದ ಮಾಡಲಾಗುತ್ತದೆ 0 ಸಾಧನವಾಗಿ ಮರಳಬಹುದು.

1761
01:30:36,630 --> 01:30:37,900
>> ಸರಿ, ಆದ್ದರಿಂದ ಸ್ಟಾಕ್ ಉಕ್ಕಿ.

1762
01:30:37,900 --> 01:30:39,320
ಇಲ್ಲಿ ಕಲ್ಪನೆ ಇಲ್ಲಿದೆ?

1763
01:30:39,320 --> 01:30:41,210
ಆದ್ದರಿಂದ ನೆನಪಿಡಿ, ರಾಶಿ ಕೆಳಗೆ ಹೋಗುತ್ತದೆ.

1764
01:30:41,210 --> 01:30:43,480
ಸ್ಟಾಕ್ ಅಪ್ ಹೋಗುತ್ತದೆ.

1765
01:30:43,480 --> 01:30:48,000
ಆದ್ದರಿಂದ ಈ ಉಪನ್ಯಾಸ ಉದಾಹರಣೆಗೆ, ಆಗಿತ್ತು
ನಾನು ಅಲ್ಲಿ ಮುಖ್ಯ ಕೇವಲ ಹೋಗುತ್ತದೆ, ಭಾವಿಸುತ್ತೇನೆ

1766
01:30:48,000 --> 01:30:51,380
ಹೋಗುತ್ತದೆ ಈ ಕಾರ್ಯ foo, ಕರೆ
ಮೇಲೆ ಪುನರಾವರ್ತಿತವಾಗಿ ಸ್ವತಃ ಕರೆ ಮತ್ತು

1767
01:30:51,380 --> 01:30:52,320
ಮತ್ತೆ.

1768
01:30:52,320 --> 01:30:55,370
>> ಆದ್ದರಿಂದ ಚೌಕಟ್ಟುಗಳು ಹೋಗುವ ಬಣವೆ
ಒಂದೇ ಕೆಲಸ.

1769
01:30:55,370 --> 01:30:58,130
ನಾವು ಮುಖ್ಯ ಆರಂಭವಾಗಬೇಕು ನೀನು
ಕೆಳಗೆ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಎಂದು.

1770
01:30:58,130 --> 01:31:02,000
ನಂತರ ಮುಖ್ಯ, foo ಕರೆ ಹೋಗುವ ಇದು
ಒಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಕಾಣುವುದು ಇದೆ.

1771
01:31:02,000 --> 01:31:04,260
>> ತದನಂತರ foo foo ಕರೆ ಹೋಗುತ್ತದೆ
ಮತ್ತೆ, ಇದು ಕಾಣುವುದು

1772
01:31:04,260 --> 01:31:05,500
ಮತ್ತೊಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್.

1773
01:31:05,500 --> 01:31:08,270
ನಂತರ ಮತ್ತೆ, ಮತ್ತೆ, ಮತ್ತು ಮತ್ತೆ,
ಮತ್ತೆ ರವರೆಗೆ, ಅಂತಿಮವಾಗಿ, ನಾವು ಔಟ್

1774
01:31:08,270 --> 01:31:09,190
ರಾಶಿ.

1775
01:31:09,190 --> 01:31:11,990
ಈ ನಾವು ಪಡೆಯುವುದು ಹೇಗೆ
ಸ್ಟಾಕ್ ಉಕ್ಕಿ.

1776
01:31:11,990 --> 01:31:14,910
ಈ ಹಂತದಲ್ಲಿ, ನೀವು seg ತಪ್ಪು.

1777
01:31:14,910 --> 01:31:17,335
ಅಥವಾ ನೀವು ನಿಜವಾಗಿಯೂ seg ಮೊದಲು ತಪ್ಪು ಮಾಡಿದೆವು
ಈ ಹಂತದಲ್ಲಿ ಆದರೆ ಹೌದು.

1778
01:31:17,335 --> 01:31:19,660
>> ಪ್ರೇಕ್ಷಕರು: ಕೋರ್ ಡಂಪ್ ಹೊಂದಿದೆ
seg ತಪ್ಪು ಅದೇ?

1779
01:31:19,660 --> 01:31:26,140
>> ರಾಬ್: ಆದ್ದರಿಂದ ನೀವು ವಿಭಜನೆ ನೋಡುತ್ತಾರೆ
ತಪ್ಪು ಕೋರ್ ಸುರಿಸಿದ.

1780
01:31:26,140 --> 01:31:28,760
ಒಂದು ಕೋರ್ ಡಂಪ್ ಮಾಡಿದಾಗ ಪಡೆಯಲು
ನೀವು seg ತಪ್ಪು.

1781
01:31:28,760 --> 01:31:32,580
ಮತ್ತು ಇದು ಎಲ್ಲಾ ಒಂದು ಡಂಪ್ ಹೀಗಿದೆ
ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಮೆಮೊರಿ ವಿಷಯಗಳನ್ನು ಆದ್ದರಿಂದ

1782
01:31:32,580 --> 01:31:36,670
ನೀವು ಪ್ರಯತ್ನಿಸಿ ಮತ್ತು ಗುರುತಿಸುವಂತಹ
ಏಕೆ ನೀವು ಟೀಕಾಕಾರರು ತಪ್ಪು seg.

1783
01:31:36,670 --> 01:31:37,135
ಹೌದು?

1784
01:31:37,135 --> 01:31:38,385
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> ರಾಬ್: ಆದ್ದರಿಂದ ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಎಂದರೆ
ಸ್ಟಾಕ್ ಉಕ್ಕಿ ಇಲ್ಲ.

1787
01:31:45,460 --> 01:31:47,060
ತೀರಾ ಅಗತ್ಯವಾಗಿ.

1788
01:31:47,060 --> 01:31:49,880
ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ನೀವು ನೀವು ಅರ್ಥ
ಒಂದು ರೀತಿಯಲ್ಲಿ ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ

1789
01:31:49,880 --> 01:31:50,880
ನೀವು ಮಾಡಬಾರದು.

1790
01:31:50,880 --> 01:31:54,750
ಆದ್ದರಿಂದ ಆ ಸಂಭವಿಸುವುದರ ಒಂದು ರೀತಿಯಲ್ಲಿ, ಆಗ
ನೀವು ನಾವು ಸ್ಪರ್ಶಿಸುವ ಆರಂಭಿಸಲು, ಉಕ್ಕಿ ಬಣವೆ

1791
01:31:54,750 --> 01:31:58,736
ನಾವು ಮಾಡಬಾರದು ಎಂದು ರೀತಿಯಲ್ಲಿ ಮೆಮೊರಿ.

1792
01:31:58,736 --> 01:31:59,208
ಹೌದು?

1793
01:31:59,208 --> 01:32:00,458
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> ರಾಬ್: ಅನಂತ ಲೂಪ್ ಒಳಗೆ ಆದ್ದರಿಂದ.

1796
01:32:05,830 --> 01:32:08,770
ಲೈಕ್, ಈ ಒಂದು ಪುನರಾವರ್ತಿತ ಅನಂತ ಹಾಗೆ
ಲೂಪ್ ಮತ್ತು ನಾವು ಮತ್ತೊಂದು ಪಡೆಯಲು

1797
01:32:08,770 --> 01:32:09,770
ಸ್ಟಾಕ್ ಪ್ರತಿ ಕಾಲಮಿತಿಯೊಳಗೆ.

1798
01:32:09,770 --> 01:32:13,540
ಆದರೆ ಕೇವಲ ಒಂದು ಸಾಮಾನ್ಯ ಒಳಗೆ
ಅನಂತ ಒಂದಾಗಿದೆ ಸಂದರ್ಭದಲ್ಲಿ

1799
01:32:13,540 --> 01:32:16,390
ಅಲ್ಲದೆ, ಅವರ ಸಹ ಮುದ್ರಿಸಲು ಅವಕಾಶ ಎಫ್

1800
01:32:16,390 --> 01:32:17,040
ಏನಾದರೂ.

1801
01:32:17,040 --> 01:32:18,390
ಇರಲಿ.

1802
01:32:18,390 --> 01:32:20,610
>> ನಾವು ಪಡೆಯಲಾಗುತ್ತದೆ ಹೋಗುತ್ತಿಲ್ಲ
ಮತ್ತೊಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್.

1803
01:32:20,610 --> 01:32:22,530
ನಾವು ಕೇವಲ ಆವರ್ತಿಸುವ ಇರಿಸಿಕೊಳ್ಳಲು ನೀನು
ಈ ಸಿಂಗಲ್ ಇನ್ಸ್ಟ್ರಕ್ಷನ್ ಮೇಲೆ.

1804
01:32:22,530 --> 01:32:23,920
ಸ್ಟಾಕ್ ಬೆಳೆಯುತ್ತಿರುವ.

1805
01:32:23,920 --> 01:32:27,290
ಇದು ಪ್ರತಿ ಪುನರಾವರ್ತಿತ ಸತ್ಯಸಂಗತಿ
ಕರೆ ನಮಗೆ ಒಂದು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ನೀಡಿದ್ದಾರೆ.

1806
01:32:27,290 --> 01:32:31,231
ನಾವು ಸ್ಟಾಕ್ ಉಕ್ಕಿ ಪಡೆಯಲು ಏಕೆ.

1807
01:32:31,231 --> 01:32:31,728
ಹೌದು?

1808
01:32:31,728 --> 01:32:38,189
>> ಪ್ರೇಕ್ಷಕರು: ಆದ್ದರಿಂದ ನೀವು ಪಡೆಯಲು ಹೇಳಿದರು
ಲೂಪ್ ಮತ್ತು ನಂತರ [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1809
01:32:38,189 --> 01:32:42,000
>> ರಾಬ್: ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಒಳಗೆ ಆದ್ದರಿಂದ
ಒಂದು printf ಇರಲಿಲ್ಲ, ನೀವು ಇನ್ನೂ ಎಂದು

1810
01:32:42,000 --> 01:32:42,790
seg ನಿಜವಾ.

1811
01:32:42,790 --> 01:32:46,090
ನಾನು ವಿಷಯಗಳನ್ನು ಗೊಂದಲ ಇಷ್ಟವಿರಲಿಲ್ಲ.

1812
01:32:46,090 --> 01:32:46,610
ಇದು ಲೂಪ್ ಎಂದು.

1813
01:32:46,610 --> 01:32:48,225
ನೀವು ಒಂದು ಸ್ಟಾಕ್ ಹೋಗಬಹುದು
printf ಫ್ರೇಮ್.

1814
01:32:48,225 --> 01:32:49,580
>> ನಂತರ printf ಹಿಂದಿರುಗುತ್ತಿದ್ದವು.

1815
01:32:49,580 --> 01:32:50,280
ನಂತರ ನೀವು ಮತ್ತೆ ಲೂಪ್ ಬಯಸುವ.

1816
01:32:50,280 --> 01:32:51,460
ನೀವು ಒಂದು ಸ್ಟಾಕ್ ಹೋಗಬಹುದು
printf ಫ್ರೇಮ್.

1817
01:32:51,460 --> 01:32:52,850
ಹಿಂತಿರುಗಿ.

1818
01:32:52,850 --> 01:32:54,060
ಏಕ ಸ್ಟಾಕ್ ಫ್ರೇಮ್.

1819
01:32:54,060 --> 01:33:00,215
ಆದ್ದರಿಂದ ಈ ಅನಂತ ಪಡೆಯದಿದ್ದಲ್ಲಿ
ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಹೇರಿ.

1820
01:33:00,215 --> 01:33:03,185
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1821
01:33:03,185 --> 01:33:04,040
>> ರಾಬ್: ಹೌದು.

1822
01:33:04,040 --> 01:33:09,360
ಆದ್ದರಿಂದ ಈ ಸ್ಟಾಕ್ ಉಕ್ಕಿ ನಡೆಯುತ್ತದೆ
ಈ ಯಾವುದೇ ಕಾರಣ

1823
01:33:09,360 --> 01:33:11,600
foo, ಕರೆಗಳನ್ನು ಹಿಂದಿರುಗುತ್ತಿದ್ದಾರೆ.

1824
01:33:11,600 --> 01:33:15,250
ನಾವು ಮರಳಿ ವೇಳೆ, ನಂತರ ನಾವು ಆದ್ದರಿಂದ
ಸ್ಟಾಕ್ ಚೌಕಟ್ಟುಗಳು ಸೋತ ಆರಂಭಿಸಲು.

1825
01:33:15,250 --> 01:33:17,870
ನಂತರ ನಾವು ಉಕ್ಕಿ ಬಣವೆ ಎಂದು.

1826
01:33:17,870 --> 01:33:20,070
ನೀವು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಅಗತ್ಯವಿದೆ ಏಕೆ ಎಂದು ಇಲ್ಲಿದೆ
ನಿಮ್ಮ ವೈಯಕ್ತಿಕ ಚಟುವಟಿಕೆಗಳಿಗೆ.

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
ಹೌದು?

1829
01:33:23,479 --> 01:33:27,375
>> ಪ್ರೇಕ್ಷಕರು: ಸಂಭಾವ್ಯ ಗಾತ್ರ ಮತ್ತು ಈಸ್
ರಾಶಿ ಒಂದೇ ಸ್ಟ್ಯಾಕ್

1830
01:33:27,375 --> 01:33:29,880
ಎಲ್ಲಾ ಕಾರ್ಯಕ್ರಮಗಳು?

1831
01:33:29,880 --> 01:33:31,910
>> ರಾಬ್: ಸ್ಥೂಲವಾಗಿ.

1832
01:33:31,910 --> 01:33:35,090
ಸ್ಟಾಕ್ ಸಂಭಾವ್ಯ ಗಾತ್ರ ಮತ್ತು
ಎಲ್ಲಾ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಅದೇ ರಾಶಿ?

1833
01:33:35,090 --> 01:33:37,180
ಸ್ಥೂಲವಾಗಿ.

1834
01:33:37,180 --> 01:33:40,080
ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಇಲ್ಲ
ಅಲ್ಲಿ ಸ್ಟಾಕ್ ಆರಂಭವಾಗಿ

1835
01:33:40,080 --> 01:33:42,400
ಅಲ್ಲಿ ರಾಶಿ ಆರಂಭವಾಗುತ್ತದೆ.

1836
01:33:42,400 --> 01:33:45,870
ನೀವು ಒಂದು ಇಡೀ ಬಹಳಷ್ಟು ಹೊಂದಿರುತ್ತವೆ ಸಂಭವಿಸಿದಾಗ
ಜಾಗತಿಕ ಅಸ್ಥಿರ ಮತ್ತು ವಿಷಯಗಳನ್ನು, ನೀವು ಮಾಡಬಹುದು

1837
01:33:45,870 --> 01:33:49,520
ಕೆಲವು ಜಾಗವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ
ನಿಮ್ಮ ರಾಶಿ ಫಾರ್.

1838
01:33:49,520 --> 01:33:54,060
>> ಒಂದು 64 ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ನೀವು ವಾಸ್ತವವಾಗಿ
ಅನಂತ ಮೆಮೊರಿ.

1839
01:33:54,060 --> 01:33:55,820
ಕೇವಲ ತುಂಬಾ ಇತ್ತು.

1840
01:33:55,820 --> 01:33:59,250
32 ಬಿಟ್ಗಳು ಮತ್ತು 64 ಬಿಟ್ಗಳು, ಆ ನಡುವೆ
ಒಂದು ಗಮನಾರ್ಹ ವ್ಯತ್ಯಾಸ.

1841
01:33:59,250 --> 01:34:02,350
>> ನೀವು ಹೆಚ್ಚು ಒಟ್ಟಾರೆಯಾಗಿ ಬಹಳಷ್ಟು ಪಡೆಯಲು ನೀನು
ಒಂದು 64 ಬಿಟ್ ಮೇಲೆ ಸ್ಟ್ಯಾಕ್ ಮತ್ತು ಹೀಪ್ ಜಾಗವನ್ನು

1842
01:34:02,350 --> 01:34:05,810
ವ್ಯವಸ್ಥೆಯನ್ನು ಹೆಚ್ಚು ಇರುವುದರಿಂದ
ಅವರು ಬಳಸಬಹುದಾದ ವಿಳಾಸಗಳು.

1843
01:34:05,810 --> 01:34:09,360
ಆದರೆ ವ್ಯಕ್ತಿಯ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಇದು
ಸ್ಟಾಕ್ ಸರಿಸುಮಾರಾಗಿ ಅದೇ ಪ್ರಮಾಣದ

1844
01:34:09,360 --> 01:34:10,785
ಮತ್ತು ರಾಶಿ ಸ್ಪೇಸ್.

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
ಸರಿ.

1847
01:34:15,530 --> 01:34:18,220
>> ಆದ್ದರಿಂದ ಕಡೆಯದಾಗಿ ಸಂಗ್ರಹವಾಗಿದೆ.

1848
01:34:18,220 --> 01:34:19,810
ಆದ್ದರಿಂದ ನೀವು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ತಿಳಿಯಬೇಕಿದೆ.

1849
01:34:19,810 --> 01:34:22,240
ನಾಲ್ಕು ದೊಡ್ಡ ಕ್ರಮಗಳನ್ನು.

1850
01:34:22,240 --> 01:34:24,400
ಮೊದಲ ಒಂದು ಮಾಡಬೇಕಾದುದು
ನೆನಪಿಡುವ ಸುಲಭ.

1851
01:34:24,400 --> 01:34:25,085
ಪೂರ್ವ ಸಂಸ್ಕರಣೆ.

1852
01:34:25,085 --> 01:34:28,390
ಅದು ಪೂರ್ವ ಪೂರ್ವಪ್ರತ್ಯಯ ಹೊಂದಿದೆ.

1853
01:34:28,390 --> 01:34:32,080
ಆದ್ದರಿಂದ ಎಲ್ಲವೂ ಮೊದಲು ಬರುತ್ತದೆ.

1854
01:34:32,080 --> 01:34:34,000
>> ನೆನಪಿಡುವ ವಿಷಯ ಹ್ಯಾಶ್ ಆಗಿದೆ.

1855
01:34:34,000 --> 01:34:37,250
ಆದ್ದರಿಂದ ಹ್ಯಾಶ್ ವರ್ಣಿಸಬಹುದು ಮತ್ತು ಹ್ಯಾಶ್ ಒಳಗೊಂಡಿದೆ
ಆ ಎಲ್ಲಾ.

1856
01:34:37,250 --> 01:34:39,560
ಆ ಎಲ್ಲಾ ಪೂರ್ವ ಪ್ರೊಸೆಸರ್ ಗಳು
ನಿರ್ದೇಶನ.

1857
01:34:39,560 --> 01:34:42,030
ಈ ವಿಷಯಗಳನ್ನು ಬಯಸುವಿರಾ
ಪೂರ್ವ ಪ್ರೊಸೆಸರ್ ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ.

1858
01:34:42,030 --> 01:34:43,680
>> ಆದ್ದರಿಂದ ಮೊದಲೇ ಪ್ರೊಸೆಸರ್ ಏನು ಮಾಡುತ್ತದೆ?

1859
01:34:43,680 --> 01:34:44,850
ಇದು ನಿಜವಾಗಿಯೂ ಮೂಕ ವಿಷಯ.

1860
01:34:44,850 --> 01:34:49,380
ಇದು ಸಾಮರ್ಥ್ಯವನ್ನು ಈ ಎಲ್ಲಾ
ಕಾಪಿ ಮತ್ತು ಕಟ್, ಮತ್ತು ಪೇಸ್ಟ್ ಕಾರ್ಯಾಚರಣೆಗಳು.

1861
01:34:49,380 --> 01:34:51,790
>> ಆದ್ದರಿಂದ ಹ್ಯಾಶ್ ಪ್ರಮಾಣಿತ i0 ಡಾಟ್ H ಒಳಗೊಂಡಿದೆ.

1862
01:34:51,790 --> 01:34:52,990
ಮಾಡುವ ಏನು?

1863
01:34:52,990 --> 01:34:56,610
ಇದು ಪ್ರಮಾಣಿತ i0 ಡಾಟ್ H ಧರಿಸುವುದನ್ನು ವಿಶೇಷವೇನು
ಫೈಲ್ ಮತ್ತು ಉನ್ನತ ಅಂಟಿಸಲು

1864
01:34:56,610 --> 01:34:58,960
ಎಲ್ಲೆಲ್ಲಿ ಇದು ಹ್ಯಾಶ್ ಒಳಗೊಂಡಿದೆ ಹೇಳುತ್ತಾರೆ
ಪ್ರಮಾಣಿತ i0 ಡಾಟ್ H.

1865
01:34:58,960 --> 01:35:02,480
>> ಮತ್ತು ಯಾವುದೇ ಹ್ಯಾಶ್ ನಾವು ಬಂದಿದೆ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು
ಕಂಡು, ಏನು ಎಂದು?

1866
01:35:02,480 --> 01:35:06,730
ಇದರ ಹ್ಯಾಶ್ ಮೌಲ್ಯವನ್ನು ನಕಲು
ಮಾಹಿತಿ ಮತ್ತು ಅಂಟಿಸುವುದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ವ್ಯಾಖ್ಯಾನಿಸುವ

1867
01:35:06,730 --> 01:35:08,500
ಎಲ್ಲೆಲ್ಲಿ ನೀವು ಮೌಲ್ಯವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ.

1868
01:35:08,500 --> 01:35:13,400
ಆದ್ದರಿಂದ ಪ್ರಿಪ್ರೊಸೆಸರ್ ಕೇವಲ ನಿಜವಾಗಿಯೂ
ಸರಳ ಪಠ್ಯ ಆಧಾರಿತ ಕಾರ್ಯಾಚರಣೆಗಳು.

1869
01:35:13,400 --> 01:35:15,870
ಇದು ಸ್ಮಾರ್ಟ್ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.

1870
01:35:15,870 --> 01:35:18,920
ಆದ್ದರಿಂದ ಎಲ್ಲವೂ ಆಗಿದೆ
ಸಂಕೀರ್ಣವಾದ.

1871
01:35:18,920 --> 01:35:22,970
>> ಈಗ ಆ ಪ್ರಿಪ್ರೊಸೆಸರ್ ಆಗಿದೆ
ಇದನ್ನು ನಾವು ವಾಸ್ತವವಾಗಿ ಕಂಪೈಲ್.

1872
01:35:22,970 --> 01:35:24,320
ಆದ್ದರಿಂದ ಕಂಪೈಲ್ ಏನು?

1873
01:35:24,320 --> 01:35:27,310
ನಾವು ಈಗ ಸಿ ಕೋಡ್ ನಿಂದ ನೀನು
ಅಸೆಂಬ್ಲಿ ಕೋಡ್.

1874
01:35:27,310 --> 01:35:27,570
ಹೌದು?

1875
01:35:27,570 --> 01:35:28,820
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> ರಾಬ್: ಹೌದು, ನಾವು ಸೆಳೆಯಿತು.

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
ಆದ್ದರಿಂದ ಕಂಪೈಲ್.

1880
01:35:38,660 --> 01:35:40,310
ನಾವು C ದಿಂದ ಅಸೆಂಬ್ಲಿಗೆ ನೀನು.

1881
01:35:40,310 --> 01:35:42,470
ಆದ್ದರಿಂದ ಈ ಒಂದು ನಿಜವಾದ ಭಾಷೆ ಬದಲಾವಣೆ.

1882
01:35:42,470 --> 01:35:45,240
ಸ್ವತಃ ಕಂಪೈಲ್ ಹೋಗುವ ಅರ್ಥ
ಹೆಚ್ಚಿನ ಮಟ್ಟದ ಭಾಷೆ

1883
01:35:45,240 --> 01:35:47,340
ಕೆಳಮಟ್ಟದಲ್ಲಿವೆ ಭಾಷೆ.

1884
01:35:47,340 --> 01:35:50,720
>> ಮತ್ತು ಸಿ ಉನ್ನತ ಮಟ್ಟದ ಭಾಷೆ
ವಿಧಾನಸಭೆ ಹೋಲಿಸಿದರೆ.

1885
01:35:50,720 --> 01:35:52,320
ವಿಧಾನಸಭೆ ಏನು?

1886
01:35:52,320 --> 01:35:56,440
ಎಂದು ತನ್ನ ಸೂಚನೆಗಳನ್ನು, ಸುಂದರ
ಹೆಚ್ಚು, ನಿಮ್ಮ ಸಿಪಿಯು ಮಾಡಿದ.

1887
01:35:56,440 --> 01:35:59,130
ಆದರೆ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಇನ್ನೂ ಮಾಡುತ್ತದೆ
ವಿಧಾನಸಭೆ ಅರ್ಥವಾಗುತ್ತಿಲ್ಲ.

1888
01:35:59,130 --> 01:36:01,570
ಇದು ಬಿಡಿಗಳು ಮತ್ತು ಶೂನ್ಯಗಳ ಅರ್ಥ.

1889
01:36:01,570 --> 01:36:06,160
ಆದ್ದರಿಂದ ಮುಂದಿನ ಹಂತದ ಜೋಡಣೆ ಇದು
ಈ ಸೂಚನೆಗಳನ್ನು ನಮ್ಮನ್ನು ತೆರೆದಿಡುತ್ತದೆ

1890
01:36:06,160 --> 01:36:08,760
ನಿಮ್ಮ ಸಿಪಿಯು ಅರ್ಥ ಮತ್ತು ವಾಸ್ತವವಾಗಿ
ಗೆ, ಅವುಗಳನ್ನು ಭಾಷಾಂತರಿಸುತ್ತದೆ

1891
01:36:08,760 --> 01:36:10,820
ಬಿಡಿಗಳು ಮತ್ತು ಶೂನ್ಯಗಳ.

1892
01:36:10,820 --> 01:36:13,570
>> ಅವಳಿ ಅಸೆಂಬ್ಲಿಗೆ ಸಿ ಆದ್ದರಿಂದ.

1893
01:36:13,570 --> 01:36:15,870
ಆದರೆ ನಾನು ಇನ್ನೂ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಹೊಂದಿಲ್ಲ.

1894
01:36:15,870 --> 01:36:19,550
ಆದ್ದರಿಂದ CS50 ಗ್ರಂಥಾಲಯದ ನಗರದ.

1895
01:36:19,550 --> 01:36:23,070
ನಾವು ಅವಳಿ ಫಾರ್ ನಿಮಗೆ ಒದಗಿಸಿದ
GetString ಹೊಂದಿರುವ ಈ CS50 ಗ್ರಂಥಾಲಯ

1896
01:36:23,070 --> 01:36:24,400
ಮತ್ತು GetInt ಮತ್ತು ಎಲ್ಲಾ.

1897
01:36:24,400 --> 01:36:25,700
>> ಆದರೆ CS50 ಗ್ರಂಥಾಲಯದ

1898
01:36:25,700 --> 01:36:27,650
ಮತ್ತು ಸ್ವತಃ ನ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಲ್ಲ.

1899
01:36:27,650 --> 01:36:29,570
ಇದು ಒಂದು ಮುಖ್ಯ ಕಾರ್ಯ ಹೊಂದಿಲ್ಲ.

1900
01:36:29,570 --> 01:36:32,230
ಇದು ಅವಳಿ ಒಂದು ಗುಂಪೇ ಇಲ್ಲಿದೆ
ನೀವು ಬಳಸಬಹುದಾದ.

1901
01:36:32,230 --> 01:36:41,730
ಆದ್ದರಿಂದ ಲಿಂಕಿಂಗ್ ನಾವು ಒಟ್ಟಿಗೆ ಎಲ್ಲಾ ತರಬಹುದು ಹೇಗೆ
ಈ ವಿವಿಧ ಬೈನರಿ ಕಡತಗಳನ್ನು

1902
01:36:41,730 --> 01:36:43,110
ನಿಜವಾದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಆಗಿ.

1903
01:36:43,110 --> 01:36:45,900
ನೀವು ಟೈಪಿಸಿದರೆ ಅದು ಒಂದು
ಡಾಟ್ ಡಾಟ್ ಔಟ್ ಕಡಿದು.

1904
01:36:45,900 --> 01:36:51,660
>> ಆದ್ದರಿಂದ ಈ ಕಡತವನ್ನು ಎಂದು ನೀವು
, ಬರೆದರು - ಯಾವುದೇ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ

1905
01:36:51,660 --> 01:36:53,620
Ceaser ಡಾಟ್ ಸಿ.

1906
01:36:53,620 --> 01:36:55,100
ಆದರೆ ಈಗ ಇದು ಕಂಪೈಲ್ ಮಾಡಲಾಗಿದೆ
ಅವಳಿ ಕೆಳಗೆ.

1907
01:36:55,100 --> 01:36:56,480
ಆದ್ದರಿಂದ Ceaser ಡಾಟ್ ಒ.

1908
01:36:56,480 --> 01:36:59,620
ಈ ನಮ್ಮ CS50 ದ್ವಿಮಾನ ಗ್ರಂಥಾಲಯಗಳು ಆಗಿದೆ.

1909
01:36:59,620 --> 01:37:02,284
ಅವರು ಜತೆಗೂಡಿಸಲಾಯಿತು ನೀವು
ಒಂದು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಆಗಿ.

1910
01:37:02,284 --> 01:37:02,758
ಹೌದು?

1911
01:37:02,758 --> 01:37:04,008
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> ರಾಬ್: ಆದ್ದರಿಂದ ಮೊದಲ ಸೇರಿವೆ, ಮರೆಯದಿರಿ
ಸೇರಿವೆ ವಾಸ್ತವವಾಗಿ ಒಂದು ಹ್ಯಾಶ್

1914
01:37:12,710 --> 01:37:13,810
ಪೂರ್ವ ಪ್ರೊಸೆಸರ್ ಹಂತ.

1915
01:37:13,810 --> 01:37:14,750
ಆದರೆ ಪ್ರತ್ಯೇಕ ಇಲ್ಲಿದೆ.

1916
01:37:14,750 --> 01:37:20,730
ನೀವು ಯಾವುದೇ ಕಾರ್ಯಗಳನ್ನು ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ ಆ
ನಂತರ ನಿಮ್ಮ ಒಂದು ಕಡತದ ಹೊರಗಡೆ,

1917
01:37:20,730 --> 01:37:26,100
ಯಾವುದೇ, ನೀವು ಏನು ಸಂಪರ್ಕಿಸುವ ಅಗತ್ಯವಿಲ್ಲ
ನೀವು ಎಲ್ಲವನ್ನೂ ಇರುವುದರಿಂದ.

1918
01:37:26,100 --> 01:37:30,310
>> ಹೇಳಿದರು printf ರಲ್ಲಿ ಲಿಂಕ್ ಮಾಡಲಾಗುತ್ತಿದೆ.

1919
01:37:30,310 --> 01:37:32,820
ನೀವು ಎಂದಾದರೂ printf ಬಳಸಲು, ಆ ವಿಷಯ
ಆ ಲಿಂಕ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ

1920
01:37:32,820 --> 01:37:35,740
ನೀವು ಬರೆಯಲಿಲ್ಲ ಏಕೆಂದರೆ.

1921
01:37:35,740 --> 01:37:39,530
ಮತ್ತು, ವಾಸ್ತವವಾಗಿ, printf ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆಗಿದೆ
ಲಿಂಕ್.

1922
01:37:39,530 --> 01:37:42,760
ನಿಮಗೆ ಗೊತ್ತಾ ಹೇಗೆ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಅಥವಾ
ನೀವು ಅದರ ನೋಡಿ, ಮಾಡಲು ಟೈಪ್

1923
01:37:42,760 --> 01:37:46,690
ಲಿಂಕ್ ಹೊಂದಿರುವ ಡ್ಯಾಶ್ ಎಲ್ CS50,
CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ?

1924
01:37:46,690 --> 01:37:49,070
ಹಾಗೆ printf, ಮತ್ತು ವಿಷಯವನ್ನು, ಹೋಗುತ್ತದೆ
ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಲಿಂಕ್.

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
ಏನು ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

1927
01:37:53,930 --> 01:37:56,280
>> ಪ್ರೇಕ್ಷಕರು: [ಕೇಳಿಸುವುದಿಲ್ಲ]?

1928
01:37:56,280 --> 01:37:58,300
>> ರಾಬ್: ಲಿಂಕ್?

1929
01:37:58,300 --> 01:38:03,450
ನಾವು ಇಡೀ ಗುಂಪೇ ಹೊಂದಿವೆ
ವಿವಿಧ ಬೈನರಿ ಕಡತಗಳನ್ನು.

1930
01:38:03,450 --> 01:38:06,410
ಈ ಅಂಗೀಕೃತ ಉದಾಹರಣೆ
ನಾವು ಬಳಸುವ CS50 ಗ್ರಂಥಾಲಯದ ಹೊಂದಿದೆ.

1931
01:38:06,410 --> 01:38:09,960
ನಾವು ಸಂಗ್ರಹಿಸಿದ ಮತ್ತು ನೀವು ಕೊಟ್ಟ
ಈ CS50 ಗ್ರಂಥಾಲಯದ ಬೈನರಿ.

1932
01:38:09,960 --> 01:38:12,410
>> ನೀವು GetString ಬಳಸಲು ಬಯಸುವ
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ.

1933
01:38:12,410 --> 01:38:14,750
ಆದ್ದರಿಂದ ನೀವು ಹೋಗಿ GetString ಬಳಸಲು.

1934
01:38:14,750 --> 01:38:19,700
ಆದರೆ ನನ್ನ ಬೈನರಿ ಕೋಡ್ ಇಲ್ಲದೆ
GetString, ನಿಮ್ಮ ಕೋಡ್ ಕಂಪೈಲ್ ಮಾಡುವಾಗ

1935
01:38:19,700 --> 01:38:23,140
ಕೆಳಗೆ, ನೀವು ವಾಸ್ತವವಾಗಿ ಔಟ್ ಸಾಧ್ಯವಿಲ್ಲ ನಿಮ್ಮ
ಪ್ರೋಗ್ರಾಂ, GetString ಸ್ಟ್ರಿಂಗ್ ಕಾರಣ

1936
01:38:23,140 --> 01:38:25,080
ಇನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಉಲ್ಲೇಖಿಸಲ್ಪಟ್ಟಿಲ್ಲ.

1937
01:38:25,080 --> 01:38:29,220
>> ನೀವು ನನ್ನ ಅವಳಿ ಲಿಂಕ್ ಮಾತ್ರ ಇದು
ಎಲ್ಲಾ, ಈಗ, GetString ಹೊಂದಿದೆ

1938
01:38:29,220 --> 01:38:31,130
ಸರಿ, ನಾನು ಮಾಡಬಹುದು
GetString ಕಾರ್ಯಗತಗೊಳಿಸಿ.

1939
01:38:31,130 --> 01:38:32,330
ನನ್ನ ಫೈಲ್ ಪೂರ್ಣಗೊಂಡಿದೆ.

1940
01:38:32,330 --> 01:38:34,208
ಮತ್ತು ನಾನು ಈ ಚಲಾಯಿಸಬಹುದು.

1941
01:38:34,208 --> 01:38:34,697
ಹೌದು?

1942
01:38:34,697 --> 01:38:37,631
>> ಪ್ರೇಕ್ಷಕರು: ಪರಿವರ್ತಿಸಲು ಲಿಂಕ್ ಡಸ್
ಯುಗಳ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದಾದ ಹೇಗೆ?

1943
01:38:37,631 --> 01:38:42,032
ನೀವು ಇತರ ಹೊಂದಿಲ್ಲ ಆದ್ದರಿಂದ ಸಹ
ಗ್ರಂಥಾಲಯಗಳು, ಇದು ಇನ್ನೂ ನೆರವೇರಿಸಲಾಯಿತು

1944
01:38:42,032 --> 01:38:44,477
ಭಾಷಾಂತರಿಸಲು ಅಗತ್ಯ
[ಕೇಳಿಸುವುದಿಲ್ಲ]?

1945
01:38:44,477 --> 01:38:48,640
>> ರಾಬ್: ಆದ್ದರಿಂದ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ
ಅವಳಿ ಇನ್ನೂ.

1946
01:38:48,640 --> 01:38:51,750
ಅದು ಇಡೀ ತುಲನೆ ವಿಶೇಷವೇನು
ಅವಳಿ ನಕ್ಷತ್ರಗಳ ಗೊಂಚಲು.

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> ಪ್ರೇಕ್ಷಕರು: ತುಂಬಾ ಧನ್ಯವಾದಗಳು.

1949
01:38:56,591 --> 01:38:58,560
>> ರಾಬ್: ತೊಂದರೆ ಇಲ್ಲ.

1950
01:38:58,560 --> 01:38:59,540
ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

1951
01:38:59,540 --> 01:39:02,001
ಇಲ್ಲವಾದರೆ, ನಾವು ಎಲ್ಲಾ ಸರಿಯಾಗುತ್ತದೆ.

1952
01:39:02,001 --> 01:39:02,690
ಸರಿ.

1953
01:39:02,690 --> 01:39:02,990
ಧನ್ಯವಾದಗಳು.

1954
01:39:02,990 --> 01:39:03,590
>> [ಚಪ್ಪಾಳೆಯನ್ನು]

1955
01:39:03,590 --> 01:39:04,490
>> ಪ್ರೇಕ್ಷಕರು: ಧನ್ಯವಾದಗಳು.

1956
01:39:04,490 --> 01:39:05,740
>> ರಾಬ್: ಹೌದು.

1957
01:39:05,740 --> 01:39:06,582