1
00:00:00,000 --> 00:00:09,572

2
00:00:09,572 --> 00:00:12,030
ರಾಬ್ ಬೌಡೆನ್: ಹಾಯ್, ನಾನು, ರಾಬ್ ಬೌಡೆನ್ ಮನುಷ್ಯ
ಮತ್ತು ಅವರ quiz0 ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

3
00:00:12,030 --> 00:00:13,280

4
00:00:13,280 --> 00:00:14,545
>> ಆದ್ದರಿಂದ, ಮೊದಲ ಪ್ರಶ್ನೆ.

5
00:00:14,545 --> 00:00:17,750
ಈ ಪ್ರಶ್ನೆ ಎಲ್ಲಿ
ನೀವು ಸಂಖ್ಯೆ ಕೋಡ್ ಅಗತ್ಯವಿದೆ

6
00:00:17,750 --> 00:00:21,270
ಬೈನರಿ ಬಲ್ಬ್ಗಳು 127.

7
00:00:21,270 --> 00:00:23,550
ನೀವು ಬಯಸಿದರೆ, ನೀವು
ಸಾಮಾನ್ಯ ಪರಿವರ್ತನೆ

8
00:00:23,550 --> 00:00:25,950
ದಶಮಾಂಶ ರಿಂದ ಅವಳಿ, bi-- ಅಥವಾ ರಿಂದ.

9
00:00:25,950 --> 00:00:28,300
ಆದರೆ ಬಹುಶಃ ವಿಶೇಷವೇನು
ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು.

10
00:00:28,300 --> 00:00:31,750
ನಾನು ನೀವು ಎಂದು ಲೆಕ್ಕಾಚಾರ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ, ಅರ್ಥ,
ಸರಿ, 1, ಹಾಗಾದರೆ, 2 ಹಾಗಾದರೆ ಆಗಿದೆ

11
00:00:31,750 --> 00:00:33,650
4 ಹಾಗಾದರೆ, 8 ಹಾಗಾದರೆ ಆಗಿದೆ.

12
00:00:33,650 --> 00:00:39,280
ಸುಲಭ ರೀತಿಯಲ್ಲಿ, 127 128 ಮೈನಸ್ ಒಂದಾಗಿದೆ.

13
00:00:39,280 --> 00:00:42,013
ಎಂದು ಅತ್ಯಂತ ಎಡಗಡೆಯ ಬಲ್ಬ್ 128-ಬಿಟ್ ಹೊಂದಿದೆ.

14
00:00:42,013 --> 00:00:43,490

15
00:00:43,490 --> 00:00:47,860
ಆದ್ದರಿಂದ 127 ಕೇವಲ ಎಲ್ಲಾ ನಿಜವಾಗಿಯೂ
ಇತರ ದೀಪಗಳಿಗೆ,

16
00:00:47,860 --> 00:00:51,420
ಎಂದು ಅತ್ಯಂತ ಎಡಗಡೆಯ ರಿಂದ
ಬಲ್ಬ್ ಮೈನಸ್ 1.

17
00:00:51,420 --> 00:00:52,800
ಆ ಪ್ರಶ್ನೆ ಅದು.

18
00:00:52,800 --> 00:00:54,060
>> ಪ್ರಶ್ನೆ ಒಂದು.

19
00:00:54,060 --> 00:00:56,710
3 ಬಿಟ್ಗಳು ಆದ್ದರಿಂದ ನೀವು
8 ವಿಶಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು.

20
00:00:56,710 --> 00:01:01,000
ಏಕೆ, ನಂತರ, ದೊಡ್ಡ ನಕಾರಾತ್ಮಕ 7
ನೀವು ಪ್ರತಿನಿಧಿಸಲು ದಶಮಾಂಶದ ಸಂಖ್ಯೆ?

21
00:01:01,000 --> 00:01:04,050
ಅಲ್ಲದೆ, ನಾವು ಮಾತ್ರ ಮಾಡಬಹುದು
8 ವಿಶಿಷ್ಟ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು,

22
00:01:04,050 --> 00:01:07,430
ನಂತರ ನಾವು ಎಂದು ನೀನು
ಶಾಲೆಯ 7 ಮೂಲಕ 0.

23
00:01:07,430 --> 00:01:08,745
0 ಮೌಲ್ಯಗಳ ಒಂದು ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

24
00:01:08,745 --> 00:01:09,980

25
00:01:09,980 --> 00:01:11,190
>> ಪ್ರಶ್ನೆ ಎರಡು.

26
00:01:11,190 --> 00:01:14,610
ಎನ್ ಬಿಟ್ಗಳು, ಹೇಗೆ ವಿವಿಧ
ಮೌಲ್ಯಗಳನ್ನು ನೀವು ಪ್ರತಿನಿಧಿಸಲು?

27
00:01:14,610 --> 00:01:19,080
ಹೀಗಾಗಿ, n ಬಿಟ್ಗಳು ಜೊತೆಗೆ, ನೀವು 2 ಹೊಂದಿವೆ
ಪ್ರತಿ ಬಿಟ್ ಸಾಧ್ಯತೆ ಮೌಲ್ಯಗಳು.

28
00:01:19,080 --> 00:01:22,300
ನಾವು 2 ಸಾಧ್ಯವಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿವೆ
ಮೊದಲ ಬಿಟ್, 2 ಸಾಧ್ಯವಿರುವ ಮೌಲ್ಯಗಳು

29
00:01:22,300 --> 00:01:24,450
ಎರಡನೇ, 2
ಮೂರನೇ ಸಾಧ್ಯ.

30
00:01:24,450 --> 00:01:28,730
ಮತ್ತು ಆದ್ದರಿಂದ ಆ 2 ಬಾರಿ 2 ಬಾರಿ 2, ಮತ್ತು
ಅಂತಿಮವಾಗಿ ಉತ್ತರವನ್ನು ಎನ್ 2.

31
00:01:28,730 --> 00:01:30,010

32
00:01:30,010 --> 00:01:31,100
>> ಪ್ರಶ್ನೆ ಮೂರು.

33
00:01:31,100 --> 00:01:33,450
ಅವಳಿ 0x50 ಯಾವುದು?

34
00:01:33,450 --> 00:01:39,490
ಆದ್ದರಿಂದ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಬಹಳ ಎಂದು ನೆನಪಿಡಿ
ಅವಳಿ ನೇರ ಪರಿವರ್ತನೆ.

35
00:01:39,490 --> 00:01:43,180
ಇಲ್ಲಿ, ನಾವು ಕೇವಲ ನೋಡಬೇಕು
5 ಮತ್ತು ಸ್ವತಂತ್ರವಾಗಿ 0.

36
00:01:43,180 --> 00:01:45,110
ಆದ್ದರಿಂದ ಬೈನರಿ 5 ಎಂಬುದರ?

37
00:01:45,110 --> 00:01:48,400
0101, ಆ 1 ಬಿಟ್ ಮತ್ತು 4 ಬಿಟ್ ನ.

38
00:01:48,400 --> 00:01:49,900
ಅವಳಿ 0 ಯಾವುದು?

39
00:01:49,900 --> 00:01:50,520
ಟ್ರಿಕಿ ಅಲ್ಲ.

40
00:01:50,520 --> 00:01:52,180
0000.

41
00:01:52,180 --> 00:01:54,970
ಆದ್ದರಿಂದ ಕೇವಲ ಅವುಗಳನ್ನು ಒಟ್ಟಾಗಿ, ಮತ್ತು
ಬೈನರಿ ರಲ್ಲಿ ಪೂರ್ಣ ಸಂಖ್ಯೆಯ.

42
00:01:54,970 --> 00:01:57,640
01010000.

43
00:01:57,640 --> 00:02:00,439
ನೀವು ಬಯಸಿದರೆ ನೀವು ಸಾಧ್ಯವೋ
ಎಂದು ಅತ್ಯಂತ ಎಡಗಡೆಯ ಶೂನ್ಯ ತೆಗೆದುಕೊಳ್ಳಲು.

44
00:02:00,439 --> 00:02:01,105
ಇದು ಅಸಂಬದ್ಧ ಇಲ್ಲಿದೆ.

45
00:02:01,105 --> 00:02:02,920

46
00:02:02,920 --> 00:02:05,733
>> ಆದ್ದರಿಂದ ಪರ್ಯಾಯವಾಗಿ,
ದಶಮಾಂಶ 0x50 ಏನು?

47
00:02:05,733 --> 00:02:08,649
ನೀವು ಬಯಸಿದರೆ ನೀವು, ನೀವು ಸಾಧ್ಯವೋ
ಬೈನರಿ ಹೆಚ್ಚು ಆರಾಮದಾಯಕ,

48
00:02:08,649 --> 00:02:11,340
ಆ ದ್ವಿಮಾನ ಉತ್ತರವನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು
ಮತ್ತು ದಶಮಾಂಶ ಒಳಗೆ ಎಂದು ಪರಿವರ್ತಿಸಲು.

49
00:02:11,340 --> 00:02:13,870
ಅಥವಾ ನಾವು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
ಹೆಕ್ಸಾಡೆಸಿಮಲ್.

50
00:02:13,870 --> 00:02:21,140
0 ಆದ್ದರಿಂದ 0 ನೇ ಸ್ಥಾನವನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು
5 ಮೊದಲ ಸ್ಥಳಕ್ಕೆ 16 ಆಗಿದೆ.

51
00:02:21,140 --> 00:02:25,990
ಇಲ್ಲಿ, ನಾವು 5 ಬಾರಿ 16 ಹೊಂದಿವೆ
ಮೊದಲ, ಸೊನ್ನೆಗೆ ಜೊತೆಗೆ 0 ಬಾರಿ 16,

52
00:02:25,990 --> 00:02:27,520
80 ಆಗಿದೆ.

53
00:02:27,520 --> 00:02:29,710
ಮತ್ತು ನೀವು ನೋಡಿವೆ
ಪ್ರಶ್ನೆಗೆ ಶೀರ್ಷಿಕೆ,

54
00:02:29,710 --> 00:02:32,920
ಇದು ಒಂದು ರೀತಿಯ ಇದು ಸಿಎಸ್ 80, ಆಗಿತ್ತು
ಈ ಸಮಸ್ಯೆಗೆ ಉತ್ತರ ಸುಳಿವನ್ನು.

55
00:02:32,920 --> 00:02:34,460

56
00:02:34,460 --> 00:02:35,420
>> ಪ್ರಶ್ನೆ ಐದು.

57
00:02:35,420 --> 00:02:40,320
ನಾವು ಇದು, ಈ ಸ್ಕ್ರ್ಯಾಚ್ ಸ್ಕ್ರಿಪ್ಟ್ ಹೊಂದಿವೆ
4 ಬಾರಿ ಕಡಲೆಕಾಯಿ ಬೆಣ್ಣೆ ಜೆಲ್ಲಿ ಪುನರಾವರ್ತಿಸುವ.

58
00:02:40,320 --> 00:02:42,800
ಆದ್ದರಿಂದ ನಾವು ಸಿ ಕೋಡ್ ಈಗ ಹಾಗೆ?

59
00:02:42,800 --> 00:02:47,730
ಹಾಗೆಯೇ, ನಾವು ಇಲ್ಲಿ ದಪ್ಪಕ್ಷರಗಳಲ್ಲಿ ಭಾಗದಲ್ಲಿ
ನೀವು ಜಾರಿಗೆ ಬಂತು ಏಕೈಕ ಭಾಗವಾಗಿದೆ.

60
00:02:47,730 --> 00:02:51,950
ನಾವು 4 ಲೂಪ್ ನ ಒಂದು 4 ಆದೇಶಗಳ
ಬಾರಿ, printf ಮಾಡುವ ಕಡಲೆಕಾಯಿ ಬೆಣ್ಣೆ ಜೆಲ್ಲಿ,

61
00:02:51,950 --> 00:02:53,910
ಹೊಸ ಲೈನ್ ಸಮಸ್ಯೆ ಕೇಳುತ್ತದೆ ಎಂದು.

62
00:02:53,910 --> 00:02:55,250

63
00:02:55,250 --> 00:02:57,490
>> ಪ್ರಶ್ನೆ ಆರು, ಮತ್ತೊಂದು ಸ್ಕ್ರ್ಯಾಚ್ ಸಮಸ್ಯೆ.

64
00:02:57,490 --> 00:03:00,210
ನಾವು ನಾವು ಶಾಶ್ವತವಾಗಿ ಲೂಪ್ ಎಂದು ನೋಡಲು.

65
00:03:00,210 --> 00:03:05,000
ನಾವು ವೇರಿಯಬಲ್ ನಾನು ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು
ತದನಂತರ 1 ನಾನು ಏರಿಕೆಯ.

66
00:03:05,000 --> 00:03:09,580
ಈಗ ನಾವು ಸಿ ರಲ್ಲಿ ಇವೆ ಹಾಗೆ ಬಯಸುವ
ನಾವು ಈ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಅನೇಕ ರೀತಿಯಲ್ಲಿ.

67
00:03:09,580 --> 00:03:12,840
ಇಲ್ಲಿ ನಾವು ಕೋಡ್ ಸಂಭವಿಸಿದ
ಒಂದು ಸ್ವಲ್ಪ (ನಿಜವಾದ) ಎಂದು ಶಾಶ್ವತವಾಗಿ ಲೂಪ್.

68
00:03:12,840 --> 00:03:16,600
ಆದ್ದರಿಂದ ನಾವು, ವೇರಿಯಬಲ್ ನಾನು ಘೋಷಿಸಲು
ಹಾಗೆ ನಾವು ಸ್ಕ್ರ್ಯಾಚ್ ವೇರಿಯಬಲ್ ನಾನು ಹೊಂದಿತ್ತು.

69
00:03:16,600 --> 00:03:21,950
ನಾನು ವೇರಿಯಬಲ್ ಘೋಷಿಸಲು ಮತ್ತು ಶಾಶ್ವತವಾಗಿ
(ನಿಜವಾದ), ನಾವು ವೇರಿಯಬಲ್ ನಾನು ಹೇಳಲು.

70
00:03:21,950 --> 00:03:25,260
Printf% ಇ ಅಥವಾ ನೀವು% ಡಿ ಬಳಸಲಾಗುತ್ತದೆ ಬಂದಿದೆ ಎಂದು ಆದ್ದರಿಂದ.

71
00:03:25,260 --> 00:03:27,985
ನಾವು ವೇರಿಯಬಲ್ ಹೇಳುತ್ತಾರೆ, ಮತ್ತು
ನಂತರ ಇದನ್ನು ಹೆಚ್ಚಿಸಲು, ನಾನು ++.

72
00:03:27,985 --> 00:03:29,560

73
00:03:29,560 --> 00:03:30,830
>> ಪ್ರಶ್ನೆ ಏಳು.

74
00:03:30,830 --> 00:03:35,560
ಈಗ ನಾವು ಹೋಲುತ್ತದೆ ಏನನ್ನಾದರೂ ಮಾಡಲು ಬಯಸುವ
ಮಾರಿಯೋ ಡಾಟ್ ಸಿ ಸಮಸ್ಯೆಗೆ ಒಂದು ಸೆಟ್.

75
00:03:35,560 --> 00:03:39,110
ನಾವು ಈ ಹ್ಯಾಶ್ಟ್ಯಾಗ್ಗಳನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುವ,
ನಾವು ಐದು ಮುದ್ರಿಸಲು ಬಯಸುವ

76
00:03:39,110 --> 00:03:40,700
ಈ ಹ್ಯಾಷೆಸ್ ಮೂರು ಆಯಾತ.

77
00:03:40,700 --> 00:03:41,770

78
00:03:41,770 --> 00:03:43,162
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಏನು ಮಾಡೋಣ?

79
00:03:43,162 --> 00:03:45,370
ಹಾಗೆಯೇ, ನಾವು ನೀವು ಇಡೀ ನೀಡಲು
ಕೋಡ್ ಗುಂಪೇ, ಮತ್ತು ನೀವು

80
00:03:45,370 --> 00:03:47,560
ಮುದ್ರಣ ಗ್ರಿಡ್ ಕಾರ್ಯ ಭರ್ತಿ ಮಾಡಬೇಕು.

81
00:03:47,560 --> 00:03:49,540
>> ಹಾಗಾಗಿ PrintGrid ರೀತಿ ಮಾಡುವುದಿಲ್ಲ?

82
00:03:49,540 --> 00:03:51,480
ನೀವು ಹಿಂದೆ ಆರ್
ಅಗಲ ಮತ್ತು ಎತ್ತರ.

83
00:03:51,480 --> 00:03:53,520
ನಾವು ಹೊರ ಹೊಂದಿವೆ 4
ಆವರ್ತನದಲ್ಲಿ, ಲೂಪ್ ನ

84
00:03:53,520 --> 00:03:57,650
ಈ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ಮೇಲೆ
ನಾವು ಮುದ್ರಿಸುತ್ತದೆ ಬಯಸುವ ಗ್ರಿಡ್.

85
00:03:57,650 --> 00:04:01,250
ನಂತರ ನಾವು, ಅಂತರ ನೆಸ್ಟೆಡ್ 4 ಆದೇಶಗಳ
ಪ್ರತಿ ಕಾಲಮ್ ಮೇಲೆ ಮುದ್ರಿಸುವ.

86
00:04:01,250 --> 00:04:06,210
ಆದ್ದರಿಂದ ಪ್ರತಿ ಸಾಲು, ನಾವು ಮುದ್ರಣ
ಪ್ರತಿ ಕಾಲಮ್, ಒಂದು ಹ್ಯಾಶ್.

87
00:04:06,210 --> 00:04:10,045
ನಂತರ ಸಾಲು ಕೊನೆಯಲ್ಲಿ ನಾವು ಮುದ್ರಿಸಲು ಒಂದು
ಏಕ ಹೊಸ ಲೈನ್ ಮುಂದಿನ ಸಾಲು ಹೋಗಲು.

88
00:04:10,045 --> 00:04:11,420
ಮತ್ತು ಇಡೀ ಗ್ರಿಡ್ ಅದು.

89
00:04:11,420 --> 00:04:12,810

90
00:04:12,810 --> 00:04:13,675
>> ಪ್ರಶ್ನೆ ಎಂಟು.

91
00:04:13,675 --> 00:04:17,170
PrintGrid ಒಂದು ಕ್ರಿಯೆ ಎಂದು ಹೇಳಲಾಗುತ್ತದೆ
ಮರಳುವುದನ್ನು ಒಂದು ಪಾರ್ಶ್ವ ಪರಿಣಾಮ, ಆದರೆ

92
00:04:17,170 --> 00:04:17,670
ಮೌಲ್ಯದ.

93
00:04:17,670 --> 00:04:19,209
ವ್ಯತ್ಯಾಸ ವಿವರಿಸಲು.

94
00:04:19,209 --> 00:04:23,080
ಆದ್ದರಿಂದ ಈ ನೀವು ವಿಚಾರಿಸಿದಾಗ ಅವಲಂಬಿಸಿದೆ
ಅಡ್ಡ ಪರಿಣಾಮವಾಗಿದೆ ಎಂಬುದನ್ನು.

95
00:04:23,080 --> 00:04:25,180
ಅಲ್ಲದೆ, ಒಂದು ರಿಟರ್ನ್ ಮೌಲ್ಯ
ನಾವು PrintGrid ತಿಳಿದಿದೆ

96
00:04:25,180 --> 00:04:28,180
ರಿಂದ, ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿವೆ
ಇಲ್ಲಿಯೇ ಶೂನ್ಯ ಹೇಳುತ್ತಾರೆ.

97
00:04:28,180 --> 00:04:31,150
ಶೂನ್ಯ ಮರಳಿಸುವ ಆದ್ದರಿಂದ ಏನು
ನಿಜವಾಗಿಯೂ ಏನು ಮರಳಿ.

98
00:04:31,150 --> 00:04:32,200

99
00:04:32,200 --> 00:04:33,620
ಆದ್ದರಿಂದ ಅಡ್ಡ ಪರಿಣಾಮ ಏನು?

100
00:04:33,620 --> 00:04:36,620
ಅಲ್ಲದೆ, ಒಂದು ಅಡ್ಡ ಪರಿಣಾಮವಾಗಿದೆ
ರೀತಿಯ ಪ್ರಚಲಿತದಲ್ಲಿರುವ ಏನು

101
00:04:36,620 --> 00:04:39,500
ಕಾರ್ಯ ಮುಗಿದ ನಂತರ
ಎಂದು, ಕೇವಲ ಮರಳಿ ಬರಲಿಲ್ಲ

102
00:04:39,500 --> 00:04:41,340
ಮತ್ತು ಇದು ಕೇವಲ ಆದಾನಗಳು ಅಲ್ಲ.

103
00:04:41,340 --> 00:04:44,970
>> ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ನಾವು ಮಾಡಬಹುದು
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಬದಲಾಯಿಸಲು.

104
00:04:44,970 --> 00:04:46,590
ಒಂದು ಅಡ್ಡ ಪರಿಣಾಮ ಎಂದು.

105
00:04:46,590 --> 00:04:49,000
ಈ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ, ಒಂದು
ಬಹಳ ಮುಖ್ಯ ಅಡ್ಡ ಪರಿಣಾಮ

106
00:04:49,000 --> 00:04:51,070
ಪರದೆಯ ಮುದ್ರಿಸುವ ಇದೆ.

107
00:04:51,070 --> 00:04:53,110
ಆದ್ದರಿಂದ ಅಡ್ಡ ಪರಿಣಾಮವಾಗಿದೆ
ಆ PrintGrid ಹೊಂದಿದೆ.

108
00:04:53,110 --> 00:04:54,980
ನಾವು ತೆರೆಗೆ ಈ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

109
00:04:54,980 --> 00:04:56,370
ಮತ್ತು ನೀವು ನಗರದ
ಒಂದು ಅಡ್ಡ ಪರಿಣಾಮ ಎಂದು,

110
00:04:56,370 --> 00:04:58,690
ಆ ವಿಷಯ ರಿಂದ
ಈ ಕಾರ್ಯ ಮುಗಿದ ನಂತರ ಮುಂದುವರಿದರೆ.

111
00:04:58,690 --> 00:05:01,481
ಆ ವ್ಯಾಪ್ತಿಗೆ ವಿಷಯ
ಈ ಕ್ರಿಯೆಯ ಅಂತಿಮವಾಗಿ

112
00:05:01,481 --> 00:05:03,380
ಬದಲಾವಣೆ ಮಾಡಲಾಗುತ್ತಿದೆ,
ಸ್ಕ್ರೀನ್ ವಿಷಯಗಳನ್ನು.

113
00:05:03,380 --> 00:05:05,200

114
00:05:05,200 --> 00:05:05,839
>> ಪ್ರಶ್ನೆ ಒಂಬತ್ತು.

115
00:05:05,839 --> 00:05:07,880
, ಕೆಳಗೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ಪರಿಗಣಿಸಿ
ಇದು ಸಾಲಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಗೆ

116
00:05:07,880 --> 00:05:09,740
ಸೇರಿಸಲಾಗಿದೆ
ಚರ್ಚೆಯ ಸಲುವಾಗಿ.

117
00:05:09,740 --> 00:05:13,480
ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಾವು ಕೇವಲ
ಸಂಗ್ರಹಿಸುವ, GetString ಕರೆ

118
00:05:13,480 --> 00:05:16,220
ಈ ವೇರಿಯಬಲ್ ರು, ಮತ್ತು ನಂತರ
ಆ ವೇರಿಯಬಲ್ ರು ಮುದ್ರಣ.

119
00:05:16,220 --> 00:05:16,720
ಸರಿ.

120
00:05:16,720 --> 00:05:19,090
ಲೈನ್ ಪ್ರಸ್ತುತ ಏಕೆ ವಿವರಿಸಲು.

121
00:05:19,090 --> 00:05:20,920
# ಸೇರಿವೆ CS50 ಡಾಟ್ H.

122
00:05:20,920 --> 00:05:23,820
ನಾವು CS50 ಡಾಟ್ H # ಸೇರಿಸಲು ಬೇಕು?

123
00:05:23,820 --> 00:05:26,180
ಸರಿ ನಾವು ಕರೆ ಮಾಡುತ್ತಿರುವ
ಕಾರ್ಯ GetString,

124
00:05:26,180 --> 00:05:28,840
ಮತ್ತು GetString ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ.

125
00:05:28,840 --> 00:05:31,600
ನಾವು ಹೊಂದಿರಲಿಲ್ಲ ಆದ್ದರಿಂದ
# ಸೇರಿವೆ CS50 ಡಾಟ್ H,

126
00:05:31,600 --> 00:05:35,760
ನಾವು ಅಂತರ್ಗತ ಘೋಷಣೆಯ ಹೋಗಬಹುದು
GetString ಕಾರ್ಯ ದೋಷ

127
00:05:35,760 --> 00:05:36,840
ಕಂಪೈಲರ್ ರಿಂದ.

128
00:05:36,840 --> 00:05:40,110
ನಾವು ಗ್ರಂಥಾಲಯದ ಸೇರಿವೆ ಅಗತ್ಯವಿದೆ
ನಾವು ಹೆಡರ್ ಕಡತವನ್ನು ಸೇರಿವೆ ಅಗತ್ಯವಿದೆ,

129
00:05:40,110 --> 00:05:42,870
ಅಥವಾ ಬೇರೆ ಕಂಪೈಲರ್ ತಿನ್ನುವೆ
GetString ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಗುರುತಿಸುತ್ತಾರೆ.

130
00:05:42,870 --> 00:05:44,380

131
00:05:44,380 --> 00:05:46,140
>> ಲೈನ್ ಎರಡು ಇರುತ್ತದೆ ಏಕೆ.

132
00:05:46,140 --> 00:05:47,890
ಆದ್ದರಿಂದ ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಐಓ ಡಾಟ್ H.

133
00:05:47,890 --> 00:05:50,430
ಇದು ನಿಖರವಾಗಿ ಅದೇ ಇಲ್ಲಿದೆ
ಹಿಂದಿನ ಸಮಸ್ಯೆಯಾಗಿ,

134
00:05:50,430 --> 00:05:53,310
ಬದಲಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಹೊರತುಪಡಿಸಿ
GetString, ನಾವು printf ಬಗ್ಗೆ ನೀವು.

135
00:05:53,310 --> 00:05:56,654
ನಾವು ಅಗತ್ಯವಿರುವ ಹೇಳಲಿಲ್ಲ ಆದ್ದರಿಂದ
ಪ್ರಮಾಣಿತ ಐಓ ಡಾಟ್ H ಸೇರಿಸಲು,

136
00:05:56,654 --> 00:05:58,820
ಆಗ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ
printf ಕಾರ್ಯವನ್ನು ಬಳಸಲು,

137
00:05:58,820 --> 00:06:00,653
ಕಂಪೈಲರ್ ಕಾರಣ
ಅದರ ಬಗ್ಗೆ ಗೊತ್ತಿಲ್ಲ ಎಂದು.

138
00:06:00,653 --> 00:06:01,750

139
00:06:01,750 --> 00:06:05,260
>> Why-- ಮಹತ್ವ ಏನು
ಸಾಲಿನ ನಾಲ್ಕು ಅನೂರ್ಜಿತ?

140
00:06:05,260 --> 00:06:08,010
ಇಲ್ಲಿ ನಾವು ಇಂಟ್ ಮುಖ್ಯ (ಶೂನ್ಯ) ಹೊಂದಿವೆ.

141
00:06:08,010 --> 00:06:10,600
ಕೇವಲ ನಾವು ಹೇಳುವ
ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ದೊರೆಯುತ್ತಿಲ್ಲ

142
00:06:10,600 --> 00:06:12,280
ಮುಖ್ಯ ವಾದಗಳನ್ನು.

143
00:06:12,280 --> 00:06:17,390
ನಾವು ಇಂಟ್ ಹೇಳುವಷ್ಟು ನೆನಪಿಡಿ
ಪ್ರಮುಖ ಇಂಟ್ argc ಸ್ಟ್ರಿಂಗ್ argv ಆವರಣ.

144
00:06:17,390 --> 00:06:20,400
ಇಲ್ಲಿ ನಾವು ಕೇವಲ ನಾವು ಹೇಳಲು ಶೂನ್ಯ ಸೇ
ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಕಡೆಗಣಿಸಿ ಮಾಡಲಾಗುತ್ತದೆ.

145
00:06:20,400 --> 00:06:21,840

146
00:06:21,840 --> 00:06:25,225
>> ನಿಖರವಾಗಿ, ಮೆಮೊರಿ ಸಂಬಂಧಿಸಿದಂತೆ, ವಿವರಿಸಿ
ಸಾಲಿನಲ್ಲಿ ಏನು GetString ಆರು ಮರಳುತ್ತದೆ.

147
00:06:25,225 --> 00:06:27,040

148
00:06:27,040 --> 00:06:31,640
GetString ಒಂದು ಬ್ಲಾಕ್ ಮರಳಲಿದ್ದಾರೆ
ಮೆಮೊರಿ, ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು.

149
00:06:31,640 --> 00:06:34,870
ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು ಹಿಂದಿರುಗಿದ
ಮೊದಲ ಅಕ್ಷರ ಸೂಚಕವನ್ನು.

150
00:06:34,870 --> 00:06:37,170
ಸ್ಟ್ರಿಂಗ್ ಚಾರ್ ಸ್ಟಾರ್ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

151
00:06:37,170 --> 00:06:41,360
ಆದ್ದರಿಂದ ಮೊದಲ ಒಂದು ಪಾಯಿಂಟರ್
ಪಾತ್ರ ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್

152
00:06:41,360 --> 00:06:43,510
ಬಳಕೆದಾರ ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ನಮೂದಿಸಿದ.

153
00:06:43,510 --> 00:06:47,070
ಮತ್ತು ಮೆಮೊರಿ malloced ಸಂಭವಿಸಿದರೆ
ಆದ್ದರಿಂದ ಮೆಮೊರಿ ಹೇರಳ ಹೊಂದಿದೆ.

154
00:06:47,070 --> 00:06:49,080

155
00:06:49,080 --> 00:06:50,450
>> ಪ್ರಶ್ನೆ 13.

156
00:06:50,450 --> 00:06:51,960
ಕೆಳಗೆ ಪ್ರೋಗ್ರಾಂ ಪರಿಗಣಿಸಿ.

157
00:06:51,960 --> 00:06:55,579
ಆದ್ದರಿಂದ ಈ ಪ್ರೋಗ್ರಾಂ ಮಾಡುತ್ತಿರುವ
1 10 ಭಾಗಿಸಿ printf ಮಾಡುವ ಇದೆ.

158
00:06:55,579 --> 00:06:57,370
ಆದ್ದರಿಂದ ಕಂಪೈಲ್ ಮಾಡುವಾಗ ಮತ್ತು
ಮರಣದಂಡನೆ, ಈ ಪ್ರೋಗ್ರಾಂ

159
00:06:57,370 --> 00:07:01,170
ಉತ್ಪನ್ನಗಳು 0.0, ಸಹ
1 10 ಭಾಗಿಸಿ 0.1 ಆಗಿದೆ.

160
00:07:01,170 --> 00:07:02,970
ಆದ್ದರಿಂದ 0.0 ಆಗಿದೆ?

161
00:07:02,970 --> 00:07:05,510
ಅಲ್ಲದೆ, ಈ ಏಕೆಂದರೆ
ಪೂರ್ಣಾಂಕ ವಿಭಾಗ.

162
00:07:05,510 --> 00:07:08,580
ಆದ್ದರಿಂದ 1 ಒಂದು ಪೂರ್ಣಾಂಕ 10 ಒಂದು ಪೂರ್ಣಾಂಕ, ಆಗಿದೆ.

163
00:07:08,580 --> 00:07:11,980
ಆದ್ದರಿಂದ 1 10, ಎಲ್ಲವನ್ನೂ ಗುರುಗಳು
ಪೂರ್ಣಾಂಕಗಳ ಎಂದು ಪರಿಗಣಿಸಲ್ಪಡುತ್ತದೆ,

164
00:07:11,980 --> 00:07:16,380
ಮತ್ತು ಸಿ, ನಾವು ಪೂರ್ಣಾಂಕ ವಿಭಾಗ ಮಾಡಿದಾಗ,
ನಾವು ಯಾವುದೇ ದಶಮಾಂಶ ಬಿಂದುವಿನ ಮೊಟಕುಗೊಳಿಸಲು.

165
00:07:16,380 --> 00:07:19,590
ಆದ್ದರಿಂದ 1 10 ಭಾಗಿಸಿ
0, ಮತ್ತು ನಂತರ ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

166
00:07:19,590 --> 00:07:24,410
ಆದ್ದರಿಂದ, ಒಂದು ಫ್ಲೋಟ್ ಎಂದು ಎಂದು ಮುದ್ರಿಸಲು
ಒಂದು ಫ್ಲೋಟ್ ಎಂದು ಮುದ್ರಿತ ಶೂನ್ಯ 0.0 ಆಗಿದೆ.

167
00:07:24,410 --> 00:07:27,400
ನಾವು 0.0 ಪಡೆಯಲು ಏಕೆ ಎಂದು ಇಲ್ಲಿದೆ.

168
00:07:27,400 --> 00:07:28,940
>> ಕೆಳಗೆ ಪ್ರೋಗ್ರಾಂ ಪರಿಗಣಿಸಿ.

169
00:07:28,940 --> 00:07:31,280
ಈಗ ನಾವು 0.1 ಮುದ್ರಿಸುವ.

170
00:07:31,280 --> 00:07:34,280
ಆದ್ದರಿಂದ ಯಾವುದೇ ಪೂರ್ಣಾಂಕ ವಿಭಾಗ,
ನಾವು, 0.1 ಮುದ್ರಿಸುವ

171
00:07:34,280 --> 00:07:37,100
ಆದರೆ ನಾವು ಮುದ್ರಿಸುವ
28 ದಶಮಾಂಶ ಸ್ಥಳಗಳಲ್ಲಿ.

172
00:07:37,100 --> 00:07:41,810
ಮತ್ತು ನಾವು ಈ 0,1000, ಸಂಪೂರ್ಣ ಗುಂಪೇ ಪಡೆಯಿರಿ
ಶೂನ್ಯಗಳ, 5 5 5, blah blah blah.

173
00:07:41,810 --> 00:07:45,495
ಅದು ಏಕೆ ಇಲ್ಲಿ ಪ್ರಶ್ನೆ
ಬದಲಿಗೆ ನಿಖರವಾಗಿ 0.1, ಎಂದು ಮುದ್ರಿಸುತ್ತದೆ?

174
00:07:45,495 --> 00:07:46,620

175
00:07:46,620 --> 00:07:49,640
>> ಇಲ್ಲಿ ಕಾರಣಕ್ಕಾಗಿ ಈಗ
ಪಾಯಿಂಟ್ ನಿಖರವಲ್ಲದಿರುವಿಕೆ ತೇಲುತ್ತಿರುವ.

176
00:07:49,640 --> 00:07:53,410
ಒಂದು ಫ್ಲೋಟ್ ಕೇವಲ 32 ಬಿಟ್ಗಳು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

177
00:07:53,410 --> 00:07:57,540
ನಾವು ಕೇವಲ ಒಂದು ಸೀಮಿತ ಸಂಖ್ಯೆಯ ಪ್ರತಿನಿಧಿಸುತ್ತವೆ
ಆ 32 ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳ

178
00:07:57,540 --> 00:07:58,560
ಬಿಟ್ಗಳು.

179
00:07:58,560 --> 00:08:01,760
ಅಲ್ಲದೆ ಅಂತಿಮವಾಗಿ ಕೊನೆಯಿಲ್ಲದ ಇಲ್ಲ
ಅನೇಕ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳ,

180
00:08:01,760 --> 00:08:04,940
ಮತ್ತು ತೇಲುವ ಅನಂತವಾದ ಇಲ್ಲ
0 ಮತ್ತು 1 ನಡುವಿನ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳ,

181
00:08:04,940 --> 00:08:07,860
ಮತ್ತು ನಾವು ನಿಸ್ಸಂಶಯವಾಗಿ ಸಾಧ್ಯವಾಯಿತು ಕೋರುತ್ತೇವೆ
ಅದಕ್ಕಿಂತಲೂ ಹೆಚ್ಚು ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು.

182
00:08:07,860 --> 00:08:13,230
ನಾವು ತ್ಯಾಗ ಮಾಡಬೇಕು
ಅತ್ಯಂತ ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

183
00:08:13,230 --> 00:08:16,960
>> ಆದ್ದರಿಂದ 0.1 ಒಂದು ಮೌಲ್ಯ, ಸ್ಪಷ್ಟವಾಗಿ
ನಾವು ನಿಖರವಾಗಿ ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

184
00:08:16,960 --> 00:08:22,500
ಆದ್ದರಿಂದ ಬದಲಿಗೆ 0.1 ಪ್ರತಿನಿಧಿಸುವ ನಾವು
ಉತ್ತಮ ಈ 0.100000 5 5 ಪ್ರತಿನಿಧಿಸಬಹುದು

185
00:08:22,500 --> 00:08:23,260
5.

186
00:08:23,260 --> 00:08:26,306
ಮತ್ತು, ಸಾಕಷ್ಟು ನಿಕಟ ಇಲ್ಲಿದೆ ಆದರೆ
ಅನ್ವಯಗಳ ಸಾಕಷ್ಟು ಫಾರ್

187
00:08:26,306 --> 00:08:28,430
ನೀವು ಬಗ್ಗೆ ಚಿಂತೆ
ಪಾಯಿಂಟ್ ನಿಖರವಲ್ಲದಿರುವಿಕೆ ತೇಲುತ್ತಿರುವ,

188
00:08:28,430 --> 00:08:30,930
ನಾವು ಪ್ರತಿನಿಧಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ
ಎಲ್ಲಾ ನಿಖರವಾಗಿ ಅಂಕಗಳನ್ನು ತೇಲುವ.

189
00:08:30,930 --> 00:08:32,500

190
00:08:32,500 --> 00:08:33,380
>> ಪ್ರಶ್ನೆ 15.

191
00:08:33,380 --> 00:08:34,679
ಕೆಳಗೆ ಕೋಡ್ ಪರಿಗಣಿಸಿ.

192
00:08:34,679 --> 00:08:36,630
ನಾವು ಕೇವಲ 1 + 1 ಮುದ್ರಿಸುವ.

193
00:08:36,630 --> 00:08:38,289
ಇಲ್ಲಿ ಯಾವುದೇ ಟ್ರಿಕ್ ಇಲ್ಲ.

194
00:08:38,289 --> 00:08:41,780
1 + 1 2 ಮಾಪನ, ಮತ್ತು
ನಾವು ಮುದ್ರಿಸುವ ಮಾಡುತ್ತಿರುವ.

195
00:08:41,780 --> 00:08:42,789
ಈ ಕೇವಲ 2 ಮುದ್ರಿಸುತ್ತದೆ.

196
00:08:42,789 --> 00:08:43,850

197
00:08:43,850 --> 00:08:44,700
>> ಪ್ರಶ್ನೆ 16.

198
00:08:44,700 --> 00:08:49,450
ಈಗ ನಾವು ಅಕ್ಷರ ಮುದ್ರಿಸುವ ನೀವು
1 ಮತ್ತು ಪಾತ್ರದ 1.

199
00:08:49,450 --> 00:08:52,110
ಆದ್ದರಿಂದ ಈ ಮಾಡುತ್ತದೆ
ಒಂದೇ ಮುದ್ರಿಸಲು?

200
00:08:52,110 --> 00:08:57,680
ಸರಿ ಪಾತ್ರ 1 ಮತ್ತು ಪಾತ್ರದ
1, ಪಾತ್ರದ 1 ASCII ಮೌಲ್ಯವನ್ನು 49 ಹೊಂದಿದೆ.

201
00:08:57,680 --> 00:09:04,840
ಈ ನಿಜವಾಗಿಯೂ 49 ಹೇಳುವ ಜೊತೆಗೆ 49, ಮತ್ತು ಇದೆ
ಅಂತಿಮವಾಗಿ ಈ 98 ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ.

202
00:09:04,840 --> 00:09:06,130
ಆದ್ದರಿಂದ ಈ 2 ಮುದ್ರಿಸಿ.

203
00:09:06,130 --> 00:09:08,070

204
00:09:08,070 --> 00:09:09,271
>> ಪ್ರಶ್ನೆ 17.

205
00:09:09,271 --> 00:09:11,520
ಅನುಷ್ಠಾನ ಪೂರ್ಣಗೊಳಿಸಿ
ರೀತಿಯಲ್ಲಿ ಕೆಳಗೆ ಬೆಸ

206
00:09:11,520 --> 00:09:14,615
ಕಾರ್ಯ ವೇಳೆ ನಿಜವಾದ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಎಂದು
ಎನ್ ಸಹ ವೇಳೆ ಎನ್ ಬೆಸ ಮತ್ತು ಸುಳ್ಳು.

207
00:09:14,615 --> 00:09:16,710

208
00:09:16,710 --> 00:09:19,330
ಈ ದೊಡ್ಡ ಉದ್ದೇಶ
ಮಾಡ್ ಆಯೋಜಕರು ಫಾರ್.

209
00:09:19,330 --> 00:09:24,530
ಆದ್ದರಿಂದ ನಾವು ನಮ್ಮ ವಾದವನ್ನು ಎನ್ ತೆಗೆದುಕೊಳ್ಳಲು,
ಎನ್ ಅಳತೆಯ 2 ಹಾಗೂ 1, ಸಮನಾಗಿರುತ್ತದೆ

210
00:09:24,530 --> 00:09:28,030
ಎಂದು ಎನ್ ಭಾಗಿಸಿ ಎಂದರ್ಥ
2 ಒಂದು ಉಳಿದ ಹೊಂದಿತ್ತು.

211
00:09:28,030 --> 00:09:33,270
N 2 ಭಾಗಿಸಿ, ಒಂದು ಉಳಿದ ಎಂದು
ಎನ್ ಬೆಸ, ಆದ್ದರಿಂದ ನಾವು ನಿಜವಾದ ಮರಳಬಹುದು ಎಂದರ್ಥ.

212
00:09:33,270 --> 00:09:34,910
ಬೇರೆ ನಾವು ತಪ್ಪು ಮರಳಬಹುದು.

213
00:09:34,910 --> 00:09:39,070
ನೀವು 2 ಸಮ ಮಾಡ್ ಎನ್ ಸಾಧಿಸಲು ಸಾಧ್ಯ
ಶೂನ್ಯ, ಬೇರೆ, ತಪ್ಪು ಮರಳಲು ನಿಜವಾದ ಹಿಂತಿರುಗಿ.

214
00:09:39,070 --> 00:09:41,600

215
00:09:41,600 --> 00:09:43,640
>> ಕೆಳಗೆ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ ಪರಿಗಣಿಸಿ.

216
00:09:43,640 --> 00:09:46,920
N ವೇಳೆ ಆದ್ದರಿಂದ ಕಡಿಮೆ ಅಥವಾ
1 ಮರಳಲು 1 ಸಮಾನವಾಗಿರುವುದಿಲ್ಲ,

217
00:09:46,920 --> 00:09:50,430
ಎನ್ ಮೈನಸ್ 1 ಎಫ್ ಬೇರೆ ರಿಟರ್ನ್ N ಬಾರಿ.

218
00:09:50,430 --> 00:09:52,556
ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯವೇನು?

219
00:09:52,556 --> 00:09:54,305
ಅಲ್ಲದೆ, ಈ ಕೇವಲ ಆಗಿದೆ
ಅಪವರ್ತನೀಯ ಕಾರ್ಯ.

220
00:09:54,305 --> 00:09:55,410

221
00:09:55,410 --> 00:09:57,405
ಈ ಚೆನ್ನಾಗಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ
ಎನ್ ಅಪವರ್ತನೀಯ ಎಂದು.

222
00:09:57,405 --> 00:09:58,720

223
00:09:58,720 --> 00:10:02,310
>> ಈಗ 19 ಪ್ರಶ್ನಿಸಲು, ನಾವು ಬಯಸುವ
ಈ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

224
00:10:02,310 --> 00:10:04,530
ನಾವು ಇದು ಪುನರಾವರ್ತನೆಯ ಮಾಡಲು ಬಯಸುವ.

225
00:10:04,530 --> 00:10:05,874
ಆದ್ದರಿಂದ ಹೇಗೆ ನಾವು ಮಾಡಬೇಕು?

226
00:10:05,874 --> 00:10:07,790
ಅಲ್ಲದೆ ಸಿಬ್ಬಂದಿ
ಪರಿಹಾರ, ಮತ್ತೆ ಇಲ್ಲ

227
00:10:07,790 --> 00:10:11,090
ನೀವು ಮಾಡಿದ ಬಹುವಿಧದಲ್ಲಿ
, ನಾವು ಈ ಇಂಟ್ ಉತ್ಪನ್ನ ಪ್ರಾರಂಭಿಸಿ

228
00:10:11,090 --> 00:10:11,812
1 ಸಮನಾಗಿರುತ್ತದೆ.

229
00:10:11,812 --> 00:10:13,520
ಮತ್ತು ಈ ಮೂಲಕ
ಲೂಪ್, ನಾವು ನೀನು

230
00:10:13,520 --> 00:10:17,590
ಅಂತಿಮವಾಗಿ ಉತ್ಪನ್ನ ಗುಣಿಸಿದಾಗ ಎಂದು
ಪೂರ್ಣ ಅಪವರ್ತನೀಯ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು.

231
00:10:17,590 --> 00:10:21,870
ಇಂಟ್ ನಾನು 2 ಸಮನಾಗಿರುತ್ತದೆ ಆದ್ದರಿಂದ, ನಾನು
ಕಡಿಮೆ ಅಥವಾ ಎನ್ ಸಮಾನವಾಗಿರುತ್ತದೆ, ನಾನು ++.

232
00:10:21,870 --> 00:10:24,130
>> ನಾನು 2 ಸಮನಾಗಿರುತ್ತದೆ ಏಕೆ ನೀವು ಆಶ್ಚರ್ಯ ಪಡುವ ಆಗಿರಬಹುದು.

233
00:10:24,130 --> 00:10:28,380
ಹಾಗೆಯೇ, ನಾವು ಮಾಡಬೇಕು ಇಲ್ಲಿ ನೆನಪು
ನಮ್ಮ ಮೂಲ ಸಂದರ್ಭದಲ್ಲಿ ಸರಿಯಾಗಿದೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

234
00:10:28,380 --> 00:10:32,180
ಎನ್ ಕಡಿಮೆ ಅಥವಾ ಸಮಾನ ವೇಳೆ ಆದ್ದರಿಂದ
1, ನಾವು 1 ಹಿಂದಿರುಗಿದ ನೀವು.

235
00:10:32,180 --> 00:10:34,830
ನಾನು 2 ಸಮನಾಗಿರುತ್ತದೆ ಇಲ್ಲಿ ಮೇಲೆ ಆದ್ದರಿಂದ, ನಾವು ಆರಂಭಿಸಲು.

236
00:10:34,830 --> 00:10:39,090
ಸರಿ ನಾನು 1, ಇಲ್ಲದಿದ್ದರೆ ನಂತರ ಮುಚ್ಚಲಿದೆ ಅಥವಾ
ಎನ್ ಲೂಪ್ ನಂತರ 1, ವೇಳೆ

237
00:10:39,090 --> 00:10:40,600
ಎಲ್ಲಾ ಕಾರ್ಯಗತಗೊಳಿಸಿ ಎಂದು.

238
00:10:40,600 --> 00:10:43,190
ಆದ್ದರಿಂದ ನಾವು ಎಂದು
1 ಇದು ರಿಟರ್ನ್ ಉತ್ಪನ್ನ,.

239
00:10:43,190 --> 00:10:45,920
ಹಾಗೆಯೇ, ವೇಳೆ ಎನ್ ಎಂದು
ಹೆಚ್ಚು ಏನು ಕಡಿಮೆ 1 ಹೊಂದಿವೆ

240
00:10:45,920 --> 00:10:49,290
ಇದು 0, ಋಣಾತ್ಮಕವಾದ 1, whatever--
ನಾವು ಇನ್ನೂ, 1 ಮರಳಿದ ಎಂದೆನಿಸಿತ್ತು

241
00:10:49,290 --> 00:10:52,260
ಇದು ನಿಖರವಾಗಿ ಏನು
ಪುನರಾವರ್ತಿತ ಆವೃತ್ತಿ ಮಾಡುತ್ತಿರುವ.

242
00:10:52,260 --> 00:10:54,660
>> ಈಗ, ಎನ್ ಹೆಚ್ಚಿನ ವೇಳೆ
1 ಹೆಚ್ಚು, ನಾವು ನೀನು

243
00:10:54,660 --> 00:10:56,550
ಕನಿಷ್ಠ ಒಂದು ಮಾಡಲು
ಪುನರಾವರ್ತನೆ ಮೇಲೆ ಈ ಲೂಪ್.

244
00:10:56,550 --> 00:11:00,630
ಆದ್ದರಿಂದ ನಾವು ಆರ್, ನ ಎನ್ 5 ಹೇಳುತ್ತಾರೆ
ಉತ್ಪನ್ನ ಬಾರಿ ಮಾಡಲು ಹೋಗುವ 2 ಸಮನಾಗಿರುತ್ತದೆ.

245
00:11:00,630 --> 00:11:02,165
ಈಗ ಉತ್ಪನ್ನದ 2.

246
00:11:02,165 --> 00:11:04,040
ಈಗ ನಾವು ಮಾಡಲು ನೀನು
ಉತ್ಪನ್ನ ಬಾರಿ 3 ಸಮನಾಗಿರುತ್ತದೆ.

247
00:11:04,040 --> 00:11:04,690
ಈಗ 6 ಇಲ್ಲಿದೆ.

248
00:11:04,690 --> 00:11:07,500
ಉತ್ಪನ್ನ ಬಾರಿ ಈಗ 24 ಇಲ್ಲಿದೆ, 4 ಸಮನಾಗಿರುತ್ತದೆ.

249
00:11:07,500 --> 00:11:10,420
ಉತ್ಪನ್ನ ಬಾರಿ ಈಗ 120 ಇಲ್ಲಿದೆ, 5 ಸಮನಾಗಿರುತ್ತದೆ.

250
00:11:10,420 --> 00:11:16,730
ಆದ್ದರಿಂದ ಅಂತಿಮವಾಗಿ, ನಾವು ಮರಳಿ ನೀವು
ಸರಿಯಾಗಿ 5 ಅಪವರ್ತನೀಯ ಇದು 120,.

251
00:11:16,730 --> 00:11:17,510
>> ಪ್ರಶ್ನೆ 20.

252
00:11:17,510 --> 00:11:22,480
ನೀವು ಭರ್ತಿ ಮಾಡಬೇಕು ಅಲ್ಲಿ ಒಂದು
ಯಾವುದೇ ಅಲ್ಗಾರಿದಮ್ ಈ ಕೋಷ್ಟಕದಲ್ಲಿ,

253
00:11:22,480 --> 00:11:25,735
ನಾವು ನೋಡಿದ ಏನು, ಎಂದು
ಈ ಕ್ರಮಾವಳಿಯ ರನ್ ಹಿಡಿಸುತ್ತದೆ

254
00:11:25,735 --> 00:11:28,060
ಬಾರಿ ಈ ಅಸಂಪಾತ ರನ್ ಬಾರಿ.

255
00:11:28,060 --> 00:11:33,270
ಆದ್ದರಿಂದ ಒಂದು ಕ್ರಮಾವಳಿ ಏನು ಎಂದು
1 ಒಮೆಗಾ, ಆದರೆ n ನ ದೊಡ್ಡ ಒ ಹೊಂದಿದೆ?

256
00:11:33,270 --> 00:11:35,970
ಆದ್ದರಿಂದ ಅನಂತ ಇದ್ದುದನ್ನು
ಇಲ್ಲಿ ಅನೇಕ ಉತ್ತರಗಳನ್ನು.

257
00:11:35,970 --> 00:11:39,790
ನಾವು ಬಹುಶಃ ಅತ್ಯಂತ ನೋಡಬಹುದು ಒಂದು
ಆಗಾಗ್ಗೆ ಕೇವಲ ರೇಖೀಯ ಶೋಧನೆ.

258
00:11:39,790 --> 00:11:42,050
>> ಆದ್ದರಿಂದ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ
ಸನ್ನಿವೇಶದಲ್ಲಿ, ನಾವು ನೀವು ಐಟಂ

259
00:11:42,050 --> 00:11:44,050
ಹುಡುಕುತ್ತಿರುವ ನಲ್ಲಿ
ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ

260
00:11:44,050 --> 00:11:47,400
ಮತ್ತು ಆದ್ದರಿಂದ 1 ಹಂತಗಳನ್ನು ಒಮೆಗಾ ರಲ್ಲಿ,
ನಾವು ಪರಿಶೀಲಿಸಿ ಮೊದಲನೆಯದಾಗಿ,

261
00:11:47,400 --> 00:11:49,740
ನಾವು ತಕ್ಷಣ ಮರಳಿ
ನಾವು ಐಟಂ ಕಂಡು.

262
00:11:49,740 --> 00:11:52,189
ಕೆಟ್ಟ ಸಂದರ್ಭಗಳಲ್ಲಿ,
ಐಟಂ, ಕೊನೆಯಲ್ಲಿ

263
00:11:52,189 --> 00:11:53,730
ಅಥವಾ ಐಟಂ ಎಲ್ಲ ಪಟ್ಟಿಯಲ್ಲಿ ಇಲ್ಲ.

264
00:11:53,730 --> 00:11:56,700
ನಾವು ಹುಡುಕಲು
ಸಂಪೂರ್ಣ ಪಟ್ಟಿ, ಎಲ್ಲಾ ಎನ್

265
00:11:56,700 --> 00:11:58,480
ಅಂಶಗಳನ್ನು ಮತ್ತು ಇದು n ನ ಒ ಏಕೆ ಆ ನ.

266
00:11:58,480 --> 00:11:59,670

267
00:11:59,670 --> 00:12:04,880
>> ಈಗ ಇದು ಎರಡೂ ಹೊಂದಿರುವ ವಿಷಯ
N ಲಾಗ್ N ಒಮೆಗಾ, ಮತ್ತು N ಲಾಗ್ N ದೊಡ್ಡ ಒ.

268
00:12:04,880 --> 00:12:08,650
ಅಲ್ಲದೆ ಹೆಚ್ಚು ಸಂಬಂಧಿಸಿದ ವಿಷಯ
ನಾವು ಇಲ್ಲಿ ಕಾಣಬಹುದು ವಿಲೀನ ಬಂದಿದೆ.

269
00:12:08,650 --> 00:12:12,950
ಆದ್ದರಿಂದ ರೀತಿಯ, ನೆನಪು ವಿಲೀನಗೊಳ್ಳಲು,
ಅಂತಿಮವಾಗಿ ಥೀಟಾ

270
00:12:12,950 --> 00:12:16,920
ಥೀಟಾ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಅಲ್ಲಿ N ಲಾಗ್ N, ಆಫ್
ಒಮೆಗಾ ಮತ್ತು ದೊಡ್ಡ O ಒಂದೇ ವೇಳೆ.

271
00:12:16,920 --> 00:12:17,580
ಎರಡೂ N ಲಾಗ್ N.

272
00:12:17,580 --> 00:12:18,690

273
00:12:18,690 --> 00:12:21,970
>> ಒಮೆಗಾ ವಿಷಯ ಯಾವುದು
n ನ, ಮತ್ತು n ನ ಒ ವರ್ಗ?

274
00:12:21,970 --> 00:12:23,990
ಸರಿ, ಮತ್ತೆ ಇಲ್ಲ
ಅನೇಕ ಸಂಭವನೀಯ ಉತ್ತರಗಳು.

275
00:12:23,990 --> 00:12:26,440
ಇಲ್ಲಿ ನಾವು ಬಬಲ್ ರೀತಿಯ ಹೇಳಲು ಉಂಟಾಗುತ್ತದೆ.

276
00:12:26,440 --> 00:12:28,840
ಅಳವಡಿಕೆಯ ರೀತಿಯ ಇಲ್ಲಿ ಕೆಲಸ.

277
00:12:28,840 --> 00:12:31,400
ಎಂದು ಬಬಲ್ ರೀತಿಯ ನೆನಪಿಡಿ
ಆ ಆಪ್ಟಿಮೈಸೇಶನ್ ಅಲ್ಲಿ ಹೊಂದಿದೆ,

278
00:12:31,400 --> 00:12:34,630
ನೀವು ಸಮರ್ಥರಾಗುತ್ತಾರೆ ವೇಳೆ
ಸಂಪೂರ್ಣ ಪಟ್ಟಿ

279
00:12:34,630 --> 00:12:37,402
ಮಾಡಲು ಅಗತ್ಯವಿಲ್ಲದೇ
ಯಾವುದೇ ವಿನಿಮಯ, ನಂತರ, ಮತ್ತು,

280
00:12:37,402 --> 00:12:40,110
ನಾವು ತಕ್ಷಣ ಮರಳಬಹುದು
ಪಟ್ಟಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ವಿಂಗಡಿಸುತ್ತದೆ.

281
00:12:40,110 --> 00:12:43,185
, ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭಗಳಲ್ಲಿ ತುಂಬಾ
ಅದು n ನ ಕೇವಲ ಒಮೆಗಾ ಇಲ್ಲಿದೆ.

282
00:12:43,185 --> 00:12:45,960
ಇದು ಕೇವಲ ಒಂದು ಚೆನ್ನಾಗಿ ಅಲ್ಲ
ಆರಂಭಿಸಲು ಪಟ್ಟಿ ವರ್ಗೀಕರಿಸಲು

283
00:12:45,960 --> 00:12:48,270
ನಂತರ ನಾವು N ಓ ವಿನಿಮಯ ವರ್ಗ ಹೊಂದಿವೆ.

284
00:12:48,270 --> 00:12:49,330

285
00:12:49,330 --> 00:12:55,610
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಆಯ್ಕೆ ರೀತಿಯ ಹೊಂದಿವೆ
ವರ್ಗ n ಫಾರ್, ಒಮೆಗಾ ಮತ್ತು ದೊಡ್ಡ ಒ ಎರಡೂ

286
00:12:55,610 --> 00:12:56,850
>> ಪ್ರಶ್ನೆ 21.

287
00:12:56,850 --> 00:12:58,870
ಪೂರ್ಣಾಂಕ ಉಕ್ಕಿ ಯಾವುದು?

288
00:12:58,870 --> 00:13:02,160
ಸರಿ ಮತ್ತೆ, ಹಿಂದೆ ಹೋಲುವ,
ನಾವು ಮಾತ್ರ ಸೀಮಿತ ಹಲವು ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ

289
00:13:02,160 --> 00:13:04,255
ಒಂದು ಪೂರ್ಣಾಂಕ ಪ್ರತಿನಿಧಿಸಲು,
ಆದ್ದರಿಂದ ಬಹುಶಃ 32 ಬಿಟ್ಗಳು.

290
00:13:04,255 --> 00:13:06,300

291
00:13:06,300 --> 00:13:09,180
ನಾವು ಒಂದು ಸಹಿ ಪೂರ್ಣಾಂಕ ಹೇಳುತ್ತಾರೆ.

292
00:13:09,180 --> 00:13:12,800
ನಂತರ ಅಂತಿಮವಾಗಿ ಅತ್ಯುನ್ನತ
ಧನಾತ್ಮಕ ಸಂಖ್ಯೆ ನಾವು ಪ್ರತಿನಿಧಿಸಬಹುದು

293
00:13:12,800 --> 00:13:15,910
2 ಗೆ 31 ಮೈನಸ್ 1.

294
00:13:15,910 --> 00:13:19,370
ನಾವು ಪ್ರಯತ್ನಿಸಿ ಆದ್ದರಿಂದ ಏನಾಗುತ್ತದೆ
ನಂತರ ಪೂರ್ಣಾಂಕ ಹೆಚ್ಚಿಸಲು?

295
00:13:19,370 --> 00:13:25,320
ಹಾಗೆಯೇ, ನಾವು 31 2 ರಿಂದ ಹೋಗಲು ನೀನು
ಮೈನಸ್ 1, ಕೆಳಗೆ ಋಣಾತ್ಮಕ 2 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ

296
00:13:25,320 --> 00:13:26,490
31.

297
00:13:26,490 --> 00:13:29,470
ಆದ್ದರಿಂದ ಈ ಪೂರ್ಣಾಂಕ ಉಕ್ಕಿ ಹೊಂದಿದೆ
ನೀವು ಏರಿಕೆಯ ಇರಿಸಿಕೊಳ್ಳಲು ಮಾಡಿದಾಗ,

298
00:13:29,470 --> 00:13:32,330
ಮತ್ತು ಅಂತಿಮವಾಗಿ ನೀವು ಸಾಧ್ಯವಿಲ್ಲ
ಯಾವುದೇ ಹೆಚ್ಚಿನ ಮತ್ತು ಇದು ಕೇವಲ ಪಡೆಯಲು

299
00:13:32,330 --> 00:13:34,520
ಮತ್ತೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಸುತ್ತಿ
ನಕಾರಾತ್ಮಕ ಮೌಲ್ಯವನ್ನು ಸುಮಾರು.

300
00:13:34,520 --> 00:13:35,850

301
00:13:35,850 --> 00:13:37,779
>> ಬಫರ್ ಬಗ್ಗೆ ಏನು?

302
00:13:37,779 --> 00:13:39,820
ಆದ್ದರಿಂದ ಒಂದು ಬಫರ್ overflow--
ಒಂದು ಬಫರ್ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ.

303
00:13:39,820 --> 00:13:41,000
ಇದು ಕೇವಲ ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್ ಇಲ್ಲಿದೆ.

304
00:13:41,000 --> 00:13:43,350
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರೀತಿಯ ಒಂದು ಬಫರ್ ಆಗಿದೆ.

305
00:13:43,350 --> 00:13:46,120
ಆದ್ದರಿಂದ ಹೆಚ್ಚು ಬಫರ್ ಆಗ
ನೀವು ಮೆಮೊರಿ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿ

306
00:13:46,120 --> 00:13:47,880
ಆ ರಚನೆಯ ಕೊನೆಯ ಮೀರಿ.

307
00:13:47,880 --> 00:13:50,410
ನೀವು ಹಾಗಾಗಿ
ಗಾತ್ರ 5 ಮತ್ತು ನೀವು ಶ್ರೇಣಿಯನ್ನು

308
00:13:50,410 --> 00:13:53,700
ಸರಣಿ ಬ್ರಾಕೆಟ್ ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಿ
5 ಅಥವಾ ಬ್ರಾಕೆಟ್ 6 ಅಥವಾ ಬ್ರಾಕೆಟ್ 7,

309
00:13:53,700 --> 00:13:56,610
ಮೀರಿ ಅಥವಾ ಏನು
ಕೊನೆಯಲ್ಲಿ, ಅಥವಾ ಏನು

310
00:13:56,610 --> 00:14:00,790
below-- ಸರಣಿ ಬ್ರಾಕೆಟ್ ಋಣಾತ್ಮಕ 1 ಹೊಂದಿವೆ
ಆ ಎಲ್ಲಾ ಬಫರ್ ಉಕ್ಕಿ ಹರಿಯುವಿಕೆಗೆ ಇವೆ.

311
00:14:00,790 --> 00:14:02,810
ನೀವು ಕೆಟ್ಟ ರೀತಿಯಲ್ಲಿ ಮೆಮೊರಿ ಸ್ಪರ್ಶಿಸುವ ನೀವು.

312
00:14:02,810 --> 00:14:04,090

313
00:14:04,090 --> 00:14:04,730
>> ಪ್ರಶ್ನೆ 23.

314
00:14:04,730 --> 00:14:05,760

315
00:14:05,760 --> 00:14:09,100
ನೀವು ಈ ಒಂದು ಆದ್ದರಿಂದ
strlen ಜಾರಿಗೆ.

316
00:14:09,100 --> 00:14:11,630
ಮತ್ತು ನಾವು ನೀವು ಎಂದು ಹೇಳಲು
ರು ಶೂನ್ಯ ಸಾಧ್ಯವಿಲ್ಲ ತಿಳಿಯುವುದು,

317
00:14:11,630 --> 00:14:13,790
ನೀವು ಹೊಂದಿಲ್ಲ
ಶೂನ್ಯ ಯಾವುದೇ ಚೆಕ್.

318
00:14:13,790 --> 00:14:16,190
ಮತ್ತು ಅನೇಕ ಮಾರ್ಗಗಳಿವೆ
ನೀವು ಈ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

319
00:14:16,190 --> 00:14:18,440
ಇಲ್ಲಿ ನಾವು ಕೇವಲ ನೇರ ತೆಗೆದುಕೊಳ್ಳಲು.

320
00:14:18,440 --> 00:14:21,780
ನಾವು N, ಕೌಂಟರ್ ಪ್ರಾರಂಭಿಸಿ. ಎನ್
ಅಲ್ಲಿ ಎಷ್ಟು ಪಾತ್ರಗಳು ಲೆಕ್ಕ.

321
00:14:21,780 --> 00:14:25,560
ಆದ್ದರಿಂದ ನಾವು ಆಗ 0 ಆರಂಭವಾಗುವುದು, ಮತ್ತು
ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಮೇಲೆ ತಿರುಗಿ.

322
00:14:25,560 --> 00:14:29,092
>> ಸಮಾನವಾಗಿರುತ್ತದೆ ರು ಬ್ರಾಕೆಟ್ 0
ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರ?

323
00:14:29,092 --> 00:14:31,425
ನಾವು ಹುಡುಕುತ್ತಿರುವ ನೆನಪಿಡಿ
ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರ

324
00:14:31,425 --> 00:14:33,360
ನಮ್ಮ ಸ್ಟ್ರಿಂಗ್ ಎಷ್ಟು ನಿರ್ಧರಿಸಲು.

325
00:14:33,360 --> 00:14:35,890
ಆ ಅಂತ್ಯಗೊಳಿಸಲು ಹೋಗುತ್ತದೆ
ಯಾವುದೇ ಸಂಬಂಧಿತ ಸ್ಟ್ರಿಂಗ್.

326
00:14:35,890 --> 00:14:39,400
ಆದ್ದರಿಂದ ರು ಬ್ರಾಕೆಟ್ ಸಮಾನ 0
ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಹೇಗೆ?

327
00:14:39,400 --> 00:14:42,850
ಇದು ಅಲ್ಲ ವೇಳೆ, ನಾವು ನೀನು
ರು ಬ್ರಾಕೆಟ್ 1, ರು ಬ್ರಾಕೆಟ್ 2 ನೋಡಲು.

328
00:14:42,850 --> 00:14:45,050
ನಾವು ವರೆಗೆ ಮುಂದುವರೆಯುತ್ತದೆ
ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಹೇಗೆ.

329
00:14:45,050 --> 00:14:48,580
ನಾವು ಕಂಡು ಒಮ್ಮೆ, ನಂತರ ಎನ್ ಹೊಂದಿದೆ
ಸ್ಟ್ರಿಂಗ್ ಒಟ್ಟು ಉದ್ದ,

330
00:14:48,580 --> 00:14:49,942
ಮತ್ತು ನಾವು ಆ ಮರಳಬಹುದು.

331
00:14:49,942 --> 00:14:51,180

332
00:14:51,180 --> 00:14:51,865
>> ಪ್ರಶ್ನೆ 24.

333
00:14:51,865 --> 00:14:53,010

334
00:14:53,010 --> 00:14:56,050
ಆದ್ದರಿಂದ ಈ ಒಂದು ಅಲ್ಲಿ ನೀವು
ವ್ಯಾಪಾರ ಆಫ್ ಮಾಡಬೇಕು.

335
00:14:56,050 --> 00:14:59,810
ಆದ್ದರಿಂದ ಒಂದು ವಿಷಯ ಒಂದು ಒಳ್ಳೆಯದು
ಆದರೆ ಯಾವ ರೀತಿಯಲ್ಲಿ ರೀತಿಯಲ್ಲಿ ಇದು ಕಳಪೆಯಾಗಿದೆ?

336
00:14:59,810 --> 00:15:02,980
ಇಲ್ಲಿ, ವಿಲೀನಗೊಳ್ಳಲು ರೀತಿಯ ಒಲವು
ಬಬಲ್ ರೀತಿಯ ವೇಗವಾಗಿ.

337
00:15:02,980 --> 00:15:06,530
ಇಲ್ಲ, ಹಾಗೂ ಆ ಹೇಳುವ ಮೂಲಕ
ಅನೇಕ ಉತ್ತರಗಳನ್ನು ಇಲ್ಲಿದ್ದೀರಿ.

338
00:15:06,530 --> 00:15:12,930
ಆದರೆ ಮುಖ್ಯ ಒಂದು ಬಬಲ್ ರೀತಿಯ ಹೊಂದಿದೆ
ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಎನ್ ಒಮೆಗಾ.

339
00:15:12,930 --> 00:15:14,950
>> ನಾವು ಹಿಂದೆ ನೋಡಿದ ಟೇಬಲ್ ನೆನಪಿಡಿ.

340
00:15:14,950 --> 00:15:17,600
ಆದ್ದರಿಂದ ಗುಳ್ಳೆ ಒಮೆಗಾ ರೀತಿಯ
ಎನ್, ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭಗಳಲ್ಲಿ

341
00:15:17,600 --> 00:15:20,010
ಇದು ಕೇವಲ ಹೋಗಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಆಗಿದೆ
ಪಟ್ಟಿ ಒಮ್ಮೆ ನಿರ್ಧರಿಸಲು

342
00:15:20,010 --> 00:15:22,270
ಆದರೂ ಈ ವಿಷಯ ಈಗಾಗಲೇ
ವಿಂಗಡಿಸಿ, ರಿಟರ್ನ್.

343
00:15:22,270 --> 00:15:25,960
ಯಾವುದೇ, ವಿಲೀನ ಏನು
ನೀವು, N ಲಾಗ್ N ಒಮೆಗಾ.

344
00:15:25,960 --> 00:15:29,200
ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಫಾರ್, ಬಬಲ್ ಆದ್ದರಿಂದ
ರೀತಿಯ ವೇಗವಾಗಿ ಎಂದು ವಿಶೇಷವೇನು.

345
00:15:29,200 --> 00:15:30,870

346
00:15:30,870 --> 00:15:32,430
>> ಈಗ ಪಟ್ಟಿಗಳನ್ನು ಬಗ್ಗೆ ಸಂಬಂಧ?

347
00:15:32,430 --> 00:15:36,070
ಆದ್ದರಿಂದ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಬೆಳೆದು ಕುಗ್ಗಿಸಿ ಮಾಡಬಹುದು
ಬೇಕಿರುವಷ್ಟು ಅಂಶಗಳನ್ನು ಹೊಂದಿಕೊಳ್ಳಲು.

348
00:15:36,070 --> 00:15:38,489
ಆದ್ದರಿಂದ ಆ ಹೇಳುವ ಮೂಲಕ
ಸಾಮಾನ್ಯವಾಗಿ ನೇರ ಹೋಲಿಕೆ

349
00:15:38,489 --> 00:15:40,280
ಸಂಬಂಧಿಸಿದ ಏರಲಿದೆ
ಸಹಿತ ಪಟ್ಟಿ.

350
00:15:40,280 --> 00:15:41,600

351
00:15:41,600 --> 00:15:44,050
ಆದ್ದರಿಂದ ಸಹ ರಚನೆಗಳು ಮಾಡಬಹುದು ಆದರೂ
ಸುಲಭವಾಗಿ ಬೆಳೆದು ಕುಗ್ಗಿಸಿ

352
00:15:44,050 --> 00:15:47,130
ಅನೇಕ ಅಂಶಗಳನ್ನು ಹೊಂದಿಕೊಳ್ಳಲು
ಮಾಹಿತಿ ಅಗತ್ಯವಿದೆ ಲಿಂಕ್ ಪಟ್ಟಿ

353
00:15:47,130 --> 00:15:49,600
ಒಂದು ರಚನೆಯ ಒಂದು ಹೋಲಿಸಿದರೆ
ಸರಣಿ ಯಾದೃಚ್ಛಿಕ ಪ್ರವೇಶ ಹೊಂದಿದೆ.

354
00:15:49,600 --> 00:15:52,960
ನಾವು ಯಾವುದೇ ಸೂಚ್ಯಂಕ
ರಚನೆಯ ನಿರ್ದಿಷ್ಟ ಅಂಶ.

355
00:15:52,960 --> 00:15:56,430
>> ಆದ್ದರಿಂದ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ, ಸಾಧ್ಯವಿಲ್ಲ
ಕೇವಲ ಐದನೇ ಅಂಶ ಹೋಗಿ,

356
00:15:56,430 --> 00:16:00,260
ನಾವು ಆರಂಭದಿಂದಲೂ ಸಂಚರಿಸುತ್ತಾರೆ ಹೊಂದಿವೆ
ನಾವು ಐದನೇ ಅಂಶ ಪಡೆಯಲು ತನಕ.

357
00:16:00,260 --> 00:16:03,990
ಮತ್ತು ತಡೆಯುತ್ತದೊ ವಿಶೇಷವೇನು
ಬೈನರಿ ಸರ್ಚ್ ಸ್ವಲ್ಪ ಮಾಡುವ.

358
00:16:03,990 --> 00:16:08,150
ಬೈನರಿ ಸರ್ಚ್ ಮಾತನಾಡುತ್ತಾ, ಬೈನರಿ ಸರ್ಚ್
ರೇಖೀಯ ಹುಡುಕಾಟ ಗಿಂತ ವೇಗವಾಗಿ ಹೊಂದುತ್ತದೆ.

359
00:16:08,150 --> 00:16:11,120
ಆ ಹೇಳುವ ಮೂಲಕ
ಆದ್ದರಿಂದ, ಒಂದು ಸಂಭವನೀಯ ವಿಷಯ

360
00:16:11,120 --> 00:16:13,380
ನೀವು ಬೈನರಿ ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು
ಲಿಂಕ್ ಪಟ್ಟಿಗಳನ್ನು ಹುಡುಕಿ,

361
00:16:13,380 --> 00:16:14,730
ನೀವು ಮಾತ್ರ ಸರಣಿಗಳ ಮೇಲೆ ಮಾಡಬಹುದು.

362
00:16:14,730 --> 00:16:18,030
ಆದರೆ ಬಹುಶಃ ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿ,
ನೀವು ಬೈನರಿ ಸರ್ಚ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ

363
00:16:18,030 --> 00:16:20,690
ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮೇಲೆ.

364
00:16:20,690 --> 00:16:23,990
ಮುಂಗಡ ನೀವು ವಿಂಗಡಿಸಲು ಬೇಕು
ಸರಣಿ, ಮತ್ತು ಕೇವಲ ನಂತರ ಮಾಡಬಹುದು

365
00:16:23,990 --> 00:16:25,370
ನೀವು ಬೈನರಿ ಸರ್ಚ್ ಮಾಡಲು.

366
00:16:25,370 --> 00:16:27,660
ನಿಮ್ಮ ಕೆಲಸವಲ್ಲ ವೇಳೆ ಆದ್ದರಿಂದ
ಆರಂಭಿಸಬೇಕು ಪ್ರತಿಗಳ,

367
00:16:27,660 --> 00:16:29,250
ನಂತರ ರೇಖೀಯ ಹುಡುಕಾಟ ವೇಗವಾಗಿ ಇರಬಹುದು.

368
00:16:29,250 --> 00:16:30,620

369
00:16:30,620 --> 00:16:31,740
>> ಪ್ರಶ್ನೆ 27.

370
00:16:31,740 --> 00:16:34,770
ಆದ್ದರಿಂದ ಕೆಳಗೆ ಕ್ರಮವಿಧಿಯನ್ನು ಪರಿಗಣಿಸಿ,
ಇದು ಮುಂದಿನ ಸ್ಲೈಡ್ ಇರುತ್ತದೆ.

371
00:16:34,770 --> 00:16:37,790
ಈ ನಾವು ನೀವು ಅಲ್ಲಿ ಒಂದಾಗಿದೆ
ಸ್ಪಷ್ಟವಾಗಿ ರಾಜ್ಯ ಬಯಸುವ ಹೋಗುವ

372
00:16:37,790 --> 00:16:39,980
ವಿವಿಧ ಚರಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು.

373
00:16:39,980 --> 00:16:41,990
ಇದರಿಂದ ಆ ನೋಡೋಣ.

374
00:16:41,990 --> 00:16:43,160
>> ಆದ್ದರಿಂದ ಒಂದು ಸಾಲು.

375
00:16:43,160 --> 00:16:45,457
ನಾವು ಇಂಟ್ X 1 ಸಮನಾಗಿರುತ್ತದೆ.

376
00:16:45,457 --> 00:16:47,040
ಆ ಹೀಗಾಗಿದೆ ಎಂದು ಮಾತ್ರ ವಿಷಯ.

377
00:16:47,040 --> 00:16:50,440
ಆದ್ದರಿಂದ ಲೈನ್ ನಲ್ಲಿ, ನಾವು ಕಾಣುವ ನಮ್ಮ
ಟೇಬಲ್, ವೈ, ಎ, ಬಿ ಮತ್ತು tmp ಎಲ್ಲಾ

378
00:16:50,440 --> 00:16:51,540
ಸ್ಥಗಿತಗೊಂಡಿತ್ತು.

379
00:16:51,540 --> 00:16:52,280
ಆದ್ದರಿಂದ X ಏನು?

380
00:16:52,280 --> 00:16:53,860
ಸರಿ ನಾವು ಅದನ್ನು 1 ಸಮಾನವಾಗಿರುತ್ತದೆ ಸೆಟ್.

381
00:16:53,860 --> 00:16:55,020

382
00:16:55,020 --> 00:16:58,770
ತದನಂತರ, ಜೊತೆಗೆ ಎರಡು ಸಾಲಿನಲ್ಲಿ
ನಾವು, ವೈ 2 ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ನೋಡಿ

383
00:16:58,770 --> 00:17:00,550
ಮತ್ತು ಟೇಬಲ್ ಈಗಾಗಲೇ
ನಮಗೆ ಭರ್ತಿ.

384
00:17:00,550 --> 00:17:03,040
ಆದ್ದರಿಂದ X 1 ಮತ್ತು ವೈ 2 ಆಗಿದೆ.

385
00:17:03,040 --> 00:17:05,890
>> ಈಗ, ಸಾಲು ಮೂರು, ನಾವು ಈಗ ಆರ್
ಸ್ವಾಪ್ ಕಾರ್ಯ ಒಳಗೆ.

386
00:17:05,890 --> 00:17:07,560
ನಾವು ಸ್ವ್ಯಾಪ್ ಹಾದು ನೀಡಲಿಲ್ಲ?

387
00:17:07,560 --> 00:17:11,609
ನಾವು ವನ್ನಾಗಲಿ X ಜಾರಿಗೆ
ಬಿ, ಮತ್ತು ವನ್ನಾಗಲಿ ವೈ.

388
00:17:11,609 --> 00:17:15,160
ಅಲ್ಲಿ ಸಮಸ್ಯೆ ಹಿಂದೆ
ತಿಳಿಸಿರುವ X ವಿಳಾಸ

389
00:17:15,160 --> 00:17:17,520
0x10, ಮತ್ತು ವೈ ವಿಳಾಸವನ್ನು 0x14 ಆಗಿದೆ.

390
00:17:17,520 --> 00:17:18,970

391
00:17:18,970 --> 00:17:21,909
ಆದ್ದರಿಂದ ಒಂದು ಮತ್ತು ಬಿ ಸಮಾನರು
ಕ್ರಮವಾಗಿ 0x10 ಮತ್ತು 0x14,.

392
00:17:21,909 --> 00:17:23,670

393
00:17:23,670 --> 00:17:26,250
>> ಈಗ ಲೈನ್ ಮೂರು, ಎಕ್ಸ್ ಮತ್ತು ವೈ ಯಾವುವು?

394
00:17:26,250 --> 00:17:28,554
ಅಲ್ಲದೆ, ಏನೂ ಬದಲಾಗಿದೆ
ಈ ಹಂತದಲ್ಲಿ x ಮತ್ತು y ಬಗ್ಗೆ.

395
00:17:28,554 --> 00:17:30,470
ಸಹ ಅವರು ಆರ್ ಆದರೂ
ಒಂದು ಮುಖ್ಯ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಒಳಗೆ,

396
00:17:30,470 --> 00:17:32,469
ಅವರು ಅದೇ ಹೊಂದಿವೆ
ಮೌಲ್ಯಗಳನ್ನು ಅವರು ಮೊದಲು ಮಾಡಿದರು.

397
00:17:32,469 --> 00:17:34,030
ನಾವು ಯಾವುದೇ ಮೆಮೊರಿ ಬದಲಾಯಿಸಲಾಗಿತ್ತು ಮಾಡಿಲ್ಲ.

398
00:17:34,030 --> 00:17:35,710
ಆದ್ದರಿಂದ X 1, ವೈ 2 ಆಗಿದೆ.

399
00:17:35,710 --> 00:17:36,550

400
00:17:36,550 --> 00:17:37,050
ಎಲ್ಲಾ ಸರಿ.

401
00:17:37,050 --> 00:17:40,300
ಈಗ ನಾವು ಒಂದು ನಟಿಸಲು ಸಮಾನ ಇಂಟ್ tmp ಹೇಳಿದರು.

402
00:17:40,300 --> 00:17:44,410
ಆದ್ದರಿಂದ ಸಾಲಿನ ನಾಲ್ಕು ಎಲ್ಲವುಗಳನ್ನು
tmp ಹೊರತುಪಡಿಸಿ ಒಂದೇ.

403
00:17:44,410 --> 00:17:47,130
ನಾವು ಯಾವುದೇ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾವಣೆಯಾಗಿಲ್ಲ
tmp ಹೊರತುಪಡಿಸಿ ಏನು.

404
00:17:47,130 --> 00:17:49,230
ನಾವು ಒಂದು ನಕ್ಷತ್ರ ಸಮಾನವಾಗಿರುತ್ತದೆ tmp ಮಾಡುತ್ತಿದ್ದೀರಿ.

405
00:17:49,230 --> 00:17:50,620
ಸ್ಟಾರ್ ಏನು?

406
00:17:50,620 --> 00:17:56,240
ಅಲ್ಲದೆ, ಒಂದು ಅಂಕಗಳನ್ನು X ಗೆ, ಆದ್ದರಿಂದ ಒಂದು ನಕ್ಷತ್ರ
1 ಇದು x =, ಹೋಗುತ್ತದೆ.

407
00:17:56,240 --> 00:18:00,080
ಆದ್ದರಿಂದ ಎಲ್ಲವೂ ನಕಲು
ಕೆಳಗೆ ಮತ್ತು tmp 1 ಹೊಂದಿಸಲಾಗಿದೆ.

408
00:18:00,080 --> 00:18:01,110
>> ಈಗ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ.

409
00:18:01,110 --> 00:18:03,380
ಸ್ಟಾರ್ ನಕ್ಷತ್ರ ಬಿ ಸಮನಾಗಿರುತ್ತದೆ.

410
00:18:03,380 --> 00:18:10,000
ಆದ್ದರಿಂದ ರೇಖೆಯಿಂದ five-- ಮತ್ತೆ, ಎಲ್ಲವೂ
ಸ್ಟಾರ್ ಯಾವುದೇ ಹೊರತುಪಡಿಸಿ ಒಂದೇ.

411
00:18:10,000 --> 00:18:10,830
ಸ್ಟಾರ್ ಏನು?

412
00:18:10,830 --> 00:18:13,720
ವೆಲ್, ನಾವು ಸ್ಟಾರ್ ಎಕ್ಸ್ ಹೇಳಿದರು.

413
00:18:13,720 --> 00:18:16,400
ನಾವು ಸಮಾನ ಸ್ಟಾರ್ ಬೌ, x ಬದಲಾಯಿಸುತ್ತಿದ್ದೇವೆ.

414
00:18:16,400 --> 00:18:18,960
ಸ್ಟಾರ್ ಬೌ ಏನು? ವೈ. ವೈ ಬಿ ಅಂಕಗಳನ್ನು.

415
00:18:18,960 --> 00:18:21,030
ಆದ್ದರಿಂದ ಸ್ಟಾರ್ ಬೌ y ಆಗಿದೆ.

416
00:18:21,030 --> 00:18:25,140
ನಾವು, ವೈ, x ಸಮಾನ ಹೊಂದಿಸುವಾಗ ನೀವು
ಮತ್ತು ಎಲ್ಲವೂ ಒಂದೇ.

417
00:18:25,140 --> 00:18:29,130
ಕ್ಷ ಈಗ ನಾವು ಮುಂದಿನ ಸತತವಾಗಿ ನೋಡಿ
2, ಮತ್ತು ಉಳಿದ ಕೆಳಗೆ ನಕಲು.

418
00:18:29,130 --> 00:18:31,120
>> ಈಗ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ, ಸ್ಟಾರ್ ಬೌ tmp ಸಮನಾಗಿರುತ್ತದೆ.

419
00:18:31,120 --> 00:18:34,740
ವೆಲ್, ನಾವು ಸ್ಟಾರ್ ಬೌ ವೈ ಹೇಳಿದರು,
ಆದ್ದರಿಂದ ನಾವು tmp ವೈ ಸಮಾನ ಹೊಂದಿಸುವಾಗ ನೀವು.

420
00:18:34,740 --> 00:18:37,450
ಎಲ್ಲವೂ ಒಂದೇ ಆಗಿದೆ
ಆದ್ದರಿಂದ ಎಲ್ಲವೂ ನಕಲಿ ಮಾಡಲಾದ ಸಿಗುತ್ತದೆ.

421
00:18:37,450 --> 00:18:42,050
ನಾವು ಇದು, tmp ಗೆ ವೈ ಸಮಾನ ಹೊಂದಿಸುವಾಗ ನೀವು
ಬೇರೆ ಒಂದು, ಮತ್ತು ಎಲ್ಲವೂ ಒಂದೇ.

422
00:18:42,050 --> 00:18:43,210
>> ಈಗ ಅಂತಿಮವಾಗಿ, ಲೈನ್ ಏಳು.

423
00:18:43,210 --> 00:18:44,700
ನಾವು ಮತ್ತೆ ಮುಖ್ಯ ಕಾರ್ಯದಲ್ಲಿ ಆರ್.

424
00:18:44,700 --> 00:18:46,350
ಸ್ವಾಪ್ ಮುಗಿದ ನಂತರ ನಾವು ಆರ್.

425
00:18:46,350 --> 00:18:48,972
ನಾವು ಒಂದು, ಬೌ ಕಳೆದುಕೊಂಡರು, ಮತ್ತು
tmp, ಆದರೆ ಅಂತಿಮವಾಗಿ

426
00:18:48,972 --> 00:18:51,180
ಯಾವುದೇ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಿದ ಇಲ್ಲ
ಈ ಹಂತದಲ್ಲಿ ಏನು,

427
00:18:51,180 --> 00:18:52,800
ನಾವು x ಮತ್ತು y ಕೆಳಗೆ ನಕಲಿಸಿ.

428
00:18:52,800 --> 00:18:56,490
ಮತ್ತು ನಾವು x ಮತ್ತು y ಎಂದು ನೋಡಿ
ಈಗ 2 ಮತ್ತು 1 ಬದಲಿಗೆ 1 ಮತ್ತು 2.

429
00:18:56,490 --> 00:18:58,160
ಸ್ವಾಪ್ ಯಶಸ್ವಿಯಾಗಿ ಕಾರ್ಯರೂಪಕ್ಕೆ ಬಂದಿದೆ.

430
00:18:58,160 --> 00:18:59,500

431
00:18:59,500 --> 00:19:00,105
>> ಪ್ರಶ್ನೆ 28.

432
00:19:00,105 --> 00:19:01,226

433
00:19:01,226 --> 00:19:03,100
ನೀವು ಎದುರಿಸುವ ಭಾವಿಸೋಣ
ದೋಷ ಸಂದೇಶಗಳನ್ನು

434
00:19:03,100 --> 00:19:06,790
ಕಚೇರಿ ಸಮಯದಲ್ಲಿ ಕೆಳಗೆ
ಒಂದು CA ಅಥವಾ ನನ್ನನ್ನು ಮುಂದಿನ ವರ್ಷ.

435
00:19:06,790 --> 00:19:08,930
ಈ ತಪ್ಪುಗಳು ಪ್ರತಿ ಸರಿಪಡಿಸಲು ಹೇಗೆ ಸಲಹೆ.

436
00:19:08,930 --> 00:19:11,160
GetString ಗೆ ಆದ್ದರಿಂದ ಸ್ಪಷ್ಟೀಕರಿಸದ ಉಲ್ಲೇಖ.

437
00:19:11,160 --> 00:19:12,540
ಏಕೆ ಈ ನೋಡಲೆಂದು?

438
00:19:12,540 --> 00:19:15,380
ಅಲ್ಲದೆ, ವಿದ್ಯಾರ್ಥಿ ಬಳಸುತ್ತಿದ್ದರೆ
ತಮ್ಮ ಕೋಡ್ GetString,

439
00:19:15,380 --> 00:19:20,310
ಅವರು ಸರಿಯಾಗಿ CS50 ಒಳಗೊಂಡಿತ್ತು ಹ್ಯಾಶ್ ಎಂದು
ಡಾಟ್ H CS50 ಗ್ರಂಥಾಲಯದ ಸೇರಿಸಲು.

440
00:19:20,310 --> 00:19:22,380
>> ಅಲ್ಲದೆ, ಅವರು ಏನು
ಈ ದೋಷವನ್ನು ಸರಿಪಡಿಸಲು ಅಗತ್ಯವಿದೆ?

441
00:19:22,380 --> 00:19:26,810
ಅವರು ಒಂದು ಡ್ಯಾಶ್ lcs50 ಏನು ಅಗತ್ಯವಿದೆ
ಅವರು ಕಂಪೈಲ್ ಮಾಡಿದಾಗ ಆಜ್ಞಾ ಸಾಲಿನ.

442
00:19:26,810 --> 00:19:29,501
ಅವರು ಹಾದು ಹೋದರೆ ಆದ್ದರಿಂದ
ಖಣಿಲು ಡ್ಯಾಶ್ lcs50, ಅವರು ಆರ್

443
00:19:29,501 --> 00:19:32,000
ನಿಜವಾದ ಮಾಡಲಿಕ್ಕೆ ಇಲ್ಲ
GetString ಅಳವಡಿಸಿಕೊಂಡ ಕೋಡ್.

444
00:19:32,000 --> 00:19:33,190

445
00:19:33,190 --> 00:19:34,170
>> ಪ್ರಶ್ನೆ 29.

446
00:19:34,170 --> 00:19:36,190
ಸೂಚ್ಯವಾಗಿ ಪ್ರಕಟಿಸಿದರು
ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ strlen.

447
00:19:36,190 --> 00:19:37,550

448
00:19:37,550 --> 00:19:40,360
ಈ ಈಗ, ಅವು ಹೊಂದಿವೆ
ಸರಿಯಾದ ಹ್ಯಾಶ್ ಮಾಡಲಾಗುತ್ತದೆ ಸೇರಿವೆ.

449
00:19:40,360 --> 00:19:41,440

450
00:19:41,440 --> 00:19:45,410
ಈ ನಿರ್ದಿಷ್ಟ ಪ್ರಕರಣದಲ್ಲಿ, ಹೆಡರ್ ಫೈಲ್
ಅವರು, ಸ್ಟ್ರಿಂಗ್ ಡಾಟ್ H ಹೊಂದಿದೆ ಸೇರಿವೆ ಅಗತ್ಯವಿದೆ

451
00:19:45,410 --> 00:19:48,710
ಮತ್ತು ಈಗ ಸ್ಟ್ರಿಂಗ್ ಡಾಟ್ H, ಸೇರಿದಂತೆ
ಈಗ student-- ಕಂಪೈಲರ್

452
00:19:48,710 --> 00:19:51,750
ಪ್ರವೇಶವನ್ನು ಹೊಂದಿದೆ
strlen ಘೋಷಣೆಗಳು,

453
00:19:51,750 --> 00:19:54,120
ಮತ್ತು ಇದು ತಿಳಿದಿದೆ ನಿಮ್ಮ ಕೋಡ್ ಎಂದು
ಸರಿಯಾಗಿ strlen ಬಳಸಿಕೊಂಡು ಇದೆ.

454
00:19:54,120 --> 00:19:55,380

455
00:19:55,380 --> 00:19:56,580
>> ಪ್ರಶ್ನೆ 30.

456
00:19:56,580 --> 00:20:00,240
ಹೆಚ್ಚು ಪ್ರತಿಶತ ಪರಿವರ್ತನೆಗಳು
ಡೇಟಾ ವಾದಗಳು ಹೆಚ್ಚು.

457
00:20:00,240 --> 00:20:01,540
ಆದ್ದರಿಂದ ಈ ಏನು?

458
00:20:01,540 --> 00:20:06,470
ಅಲ್ಲದೆ ಈ ರಷ್ಟು ನೆನಪು
ಅವರು printf ಸಂಬಂಧಿಸಿದ ನೀವು ಹೇಗೆ signs--.

459
00:20:06,470 --> 00:20:08,890
ಆದ್ದರಿಂದ printf ನಾವು percent-- ಇರಬಹುದು
ನಾವು ಏನನ್ನಾದರೂ ಮುದ್ರಿಸಲು ಇರಬಹುದು

460
00:20:08,890 --> 00:20:11,380
ಶೇಕಡಾ ಹಾಗೆ ನಾನು N ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್.

461
00:20:11,380 --> 00:20:15,310
ಅಥವಾ ನಾವು, ಶೇಕಡಾ ನಾನು ಹಾಗೆ ಮುದ್ರಿಸಲು ಇರಬಹುದು
ಸ್ಪೇಸ್, ಶೇಕಡಾ ನಾನು, ಬಾಹ್ಯಾಕಾಶ, ಶೇಕಡಾ ನಾನು.

462
00:20:15,310 --> 00:20:18,950
ಆ ಪ್ರತಿಯೊಂದು ಆದ್ದರಿಂದ
ಶೇಕಡಾ ಚಿಹ್ನೆಗಳು, ನಾವು ಅಗತ್ಯವಿದೆ

463
00:20:18,950 --> 00:20:21,560
printf ಕೊನೆಯಲ್ಲಿ ವೇರಿಯಬಲ್ ಹಾದು.

464
00:20:21,560 --> 00:20:26,980
>> ನಾವು ಹೇಳಲು ವೇಳೆ, printf ಆವರಣ ರಷ್ಟು
ನಾನು, ಎನ್ ನಿಕಟ ಆವರಣ ಬ್ಯಾಕ್ಸ್ಲ್ಯಾಷ್

465
00:20:26,980 --> 00:20:30,270
ಜೊತೆಗೆ, ನಾವು ಎಂದು ಹೇಳಲು
ಒಂದು ಪೂರ್ಣಾಂಕ ಮುದ್ರಿಸಲು ಹೋಗುತ್ತದೆ

466
00:20:30,270 --> 00:20:33,970
ಆದರೆ ನಂತರ ನಾವು printf ತೇರ್ಗಡೆಹೊಂದಿಲ್ಲ
ಒಂದು ಪೂರ್ಣಾಂಕ ವಾಸ್ತವವಾಗಿ ಮುದ್ರಿಸಲು.

467
00:20:33,970 --> 00:20:37,182
ಇಲ್ಲಿ ಹೆಚ್ಚು ಪ್ರತಿಶತ
ಡೇಟಾ ವಾದಗಳು ಹೆಚ್ಚು ಪರಿವರ್ತನೆಗಳು?

468
00:20:37,182 --> 00:20:39,390
ಎಂದು ನಾವು ಹೇಳುವ
percents ಇಡೀ ಗುಂಪೇ,

469
00:20:39,390 --> 00:20:42,445
ಮತ್ತು ನಾವು ಸಾಕಷ್ಟು ಅಸ್ಥಿರ ಇಲ್ಲ
ವಾಸ್ತವವಾಗಿ ಆ percents ತುಂಬಲು.

470
00:20:42,445 --> 00:20:44,850

471
00:20:44,850 --> 00:20:50,010
>> ತದನಂತರ ಖಂಡಿತವಾಗಿಯೂ, ಪ್ರಶ್ನೆ 31,
ಖಂಡಿತವಾಗಿಯೂ ಒಂದು ಖಂಡದಲ್ಲಿ 40 ಬೈಟ್ಗಳು ಕಳೆದುಕೊಂಡ.

472
00:20:50,010 --> 00:20:52,350
ಆದ್ದರಿಂದ ಈ ಒಂದು Valgrind, ದೋಷ.

473
00:20:52,350 --> 00:20:54,720
ಈ ಎಂದು ಇದೆ
ಎಲ್ಲೋ ನಿಮ್ಮ ಕೋಡ್ ನಲ್ಲಿ,

474
00:20:54,720 --> 00:20:59,010
ನೀವು 40 ಎಂದು ಹಂಚಿಕೆ ಹೊಂದಿರುತ್ತವೆ
ಬೈಟ್ಗಳು ದೊಡ್ಡ ಆದ್ದರಿಂದ ನೀವು, 40 ಬೈಟ್ಗಳು malloced

475
00:20:59,010 --> 00:21:00,515
ಮತ್ತು ನೀವು ಬಿಡುಗಡೆಯಾಗಲೇ ಇಲ್ಲ.

476
00:21:00,515 --> 00:21:02,480

477
00:21:02,480 --> 00:21:05,140
ನೀವು ಅಗತ್ಯವಿದೆ ಹೆಚ್ಚಾಗಿ
ಕೆಲವು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹುಡುಕಲು,

478
00:21:05,140 --> 00:21:07,650
ಮತ್ತು ನೀವು ಅಗತ್ಯವಿದೆ ಅಲ್ಲಿ ಕಾಣಬಹುದು
ಮೆಮೊರಿ ಈ ಬ್ಲಾಕ್ ಮುಕ್ತಗೊಳಿಸಲು.

479
00:21:07,650 --> 00:21:08,780

480
00:21:08,780 --> 00:21:11,910
>> ಮತ್ತು, 32 ಪ್ರಶ್ನಿಸಲು
ಗಾತ್ರ 4 ಅಮಾನ್ಯವಾಗಿದೆ ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ.

481
00:21:11,910 --> 00:21:13,250
ಮತ್ತೆ ಈ ಒಂದು Valgrind, ದೋಷ.

482
00:21:13,250 --> 00:21:15,440
ಈ ಮಾಡಲು ಹೊಂದಿಲ್ಲ
ಈಗ ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಜೊತೆ.

483
00:21:15,440 --> 00:21:20,750
ಈ ನನ್ನ ಪ್ರಕಾರ likely-- ಅತ್ಯಂತ, ಇದು ಇಲ್ಲಿದೆ, ಆಗಿದೆ
ಅಮಾನ್ಯವಾಗಿದೆ ಮೆಮೊರಿ ಹಕ್ಕುಗಳ ಕೆಲವು ರೀತಿಯ.

484
00:21:20,750 --> 00:21:23,270
ಮತ್ತು ಹೆಚ್ಚಾಗಿ ಇದು ಕೆಲವು
ಬಫರ್ ರೀತಿಯ.

485
00:21:23,270 --> 00:21:26,560
ಅಲ್ಲಿ ನೀವು ಬಹುಶಃ, ಒಂದು ಸರಣಿ
ಒಂದು ಪೂರ್ಣಾಂಕ ರಚನೆಯ, ಮತ್ತು ಅವಕಾಶ

486
00:21:26,560 --> 00:21:30,115
ಇದು ಗಾತ್ರ 5 ಹೇಳುತ್ತಾರೆ, ಮತ್ತು ನೀವು
ಸರಣಿ ಬ್ರಾಕೆಟ್ 5 ಮುಟ್ಟಲು ಪ್ರಯತ್ನಿಸಿ.

487
00:21:30,115 --> 00:21:34,150
ನೀವು ಬರೆಯಲು ಪ್ರಯತ್ನಿಸಿ ಆದ್ದರಿಂದ
ಮೌಲ್ಯ, ಆ ಮೆಮೊರಿ ತುಂಡು ಅಲ್ಲ

488
00:21:34,150 --> 00:21:37,440
ನೀವು ನಿಜವಾಗಿಯೂ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಮತ್ತು
ಆದ್ದರಿಂದ ನೀವು ಈ ದೋಷ ಪಡೆಯಲು ನೀನು,

489
00:21:37,440 --> 00:21:39,272
ಗಾತ್ರ 4 ಅಮಾನ್ಯವಾದ ಬರಹ ಹೇಳುವ.

490
00:21:39,272 --> 00:21:42,480
Valgrind ನೀವು ಕೋರುತ್ತೇವೆ ಗುರುತಿಸಲು ಹೋಗುತ್ತದೆ
ಅನುಚಿತವಾಗಿ ಮೆಮೊರಿ ಸ್ಪರ್ಶಕ್ಕೆ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ.

491
00:21:42,480 --> 00:21:43,980
>> ಮತ್ತು quiz0 ಅದು.

492
00:21:43,980 --> 00:21:47,065
ನಾನು ರಾಬ್ ಬೌಡೆನ್ ಮನುಷ್ಯ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

493
00:21:47,065 --> 00:21:51,104