1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [ವೀಕ್ 6]

2
00:00:02,000 --> 00:00:04,000
[ಡೇವಿಡ್ ಜೆ Malan] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

3
00:00:04,000 --> 00:00:08,000
[ಈ CS50 ಹೊಂದಿದೆ.] [CS50.TV]

4
00:00:08,000 --> 00:00:12,000
>> ಈ CS50 ಆಗಿದೆ, ಮತ್ತು ಈ ವಾರ 6 ಆರಂಭವಾದ

5
00:00:12,000 --> 00:00:16,000
ಆದ್ದರಿಂದ ಹೊಸ ಉಪಕರಣಗಳು ಒಂದೆರಡು, ಈಗ ನೀವು ಲಾಭ ಪಡೆಯಲು ಲಭ್ಯವಿದೆ

6
00:00:16,000 --> 00:00:19,000
ಇದು ಮೊದಲ CS50 ಶೈಲಿ ಎಂದು ಕರೆಯುತ್ತಾರೆ.

7
00:00:19,000 --> 00:00:22,000
ನೀವು ನನ್ನನ್ನು ಅಥವಾ ಇತರ ಫೆಲೋಗಳು ಯಾವುದೇ ರೀತಿಯ ಇಂತಹ ಆಡ್ಸ್ ಗಳು

8
00:00:22,000 --> 00:00:26,000
ನೀವು ಬಹುಶಃ ಯಾರ ಶೈಲಿಯನ್ನು ಹೀಗೆ ಸ್ವಲ್ಪ ಏನಾದರೂ ತೋರುತ್ತಿದೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ನೋಡಬಹುದು.

9
00:00:26,000 --> 00:00:30,000
, ಬಹುಶಃ ನೀವು ತಡರಾತ್ರಿಯಲ್ಲಿ ಕೆಲವು ಮೂಲೆಗಳಲ್ಲಿ ಕತ್ತರಿಸುವ ಆರಂಭಿಸಬಹುದು, ಅಥವಾ ನೀವು ನಂತರ ವ್ಯವಹರಿಸಲು ವಿಲ್

10
00:00:30,000 --> 00:00:32,000
ಮತ್ತು ನಂತರ ಒಂದು TF ಅಥವಾ ಸಿಎ ಕಚೇರಿ ಸಮಯದಲ್ಲಿ ಮೇಲೆ ಬರುತ್ತದೆ.

11
00:00:32,000 --> 00:00:34,000
ನಮಗೆ ಓದಲು ನಂತರ ಅದು ಕಷ್ಟ.

12
00:00:34,000 --> 00:00:38,000
ಅಲ್ಲದೆ, ಈ ಕೋಡ್ syntactically ಸರಿಯಾಗಿದೆ, ಮತ್ತು ಇದು ಕಂಪೈಲ್ ಕಾಣಿಸುತ್ತದೆ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಓಡಿದ ಕಾಣಿಸುತ್ತದೆ.

13
00:00:38,000 --> 00:00:40,000
ಆದರೆ ಇದು ಖಂಡಿತವಾಗಿ ಶೈಲಿಯ ಒಂದು 5 ಅಲ್ಲ.

14
00:00:40,000 --> 00:00:45,000
>> ಆದರೆ ಈಗ, ನಾವು ಈ ಕೋಶಕ್ಕೆ ಹೋದರೆ ಇಲ್ಲಿಗೆ

15
00:00:45,000 --> 00:00:48,000
ಮತ್ತು ನಾನು ಹೊಂದಿರುವ conditions2.c-ಗಮನಕ್ಕೆ

16
00:00:48,000 --> 00:00:55,000
ಮತ್ತು ನಾನು, ನಮೂದಿಸಿ, ಈ ಫೈಲ್ conditions2.c ಈ ಹೊಸ ಆದೇಶ, style50, ರನ್

17
00:00:55,000 --> 00:00:57,000
ಅದು ವಿಲಕ್ಷಣವಾಗಿ ಬಂದಿರುವ ನನಗೆ ತಿಳಿಸಲಾಯಿತು ಎಂದು ಗಮನಿಸಿ.

18
00:00:57,000 --> 00:01:00,000
ಜಿಎಡಿಟ್ Name, ಕಡತ ಡಿಸ್ಕಿನಲ್ಲಿ ಬದಲಾಯಿಸಲಾಗಿದೆ ಗಮನಿಸಿದರು

19
00:01:00,000 --> 00:01:08,000
ನಾನು ಮರುಲೋಡ್ ಕ್ಲಿಕ್ ಮಾಡಿದರೆ, ನಿಮ್ಮ ಎಲ್ಲ ಸಮಸ್ಯೆಗಳು ಈಗ ಸ್ವಯಂಕಾರ್ಯ.

20
00:01:08,000 --> 00:01:15,000
[ಚಪ್ಪಾಳೆಯನ್ನು]

21
00:01:15,000 --> 00:01:17,000
ನಾವು ಈ ವಾರಾಂತ್ಯದಲ್ಲಿ ಮಾಡಿದರು ವಸ್ತುಗಳ ಒಂದಾಗಿದೆ.

22
00:01:17,000 --> 00:01:20,000
ಕೆಲವು ಕೋಡ್ ಇರುವುದರಿಂದ ಅದು ಅಪೂರ್ಣ ಎಂದು ಅರ್ಥ

23
00:01:20,000 --> 00:01:23,000
ಇದು ಕೇವಲ ಸಂಪೂರ್ಣವಾಗಿ stylize ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಎಂದು

24
00:01:23,000 --> 00:01:26,000
ಆದರೆ ಅರ್ಥ ಈಗ ನೀವು ಅನುಕೂಲಗಳನ್ನು ಪಡೆಯಲು ಒಂದು ಸಾಧನವಾಗಿದೆ

25
00:01:26,000 --> 00:01:33,000
ಮಾತ್ರ ಹೆಚ್ಚು errantly ಇರಿಸಲಾಗುತ್ತದೆ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ನ ಅಚ್ಚುಕಟ್ಟಾದ ಕೆಲವು ಮತ್ತು ಇಷ್ಟಪಡುವ.

26
00:01:33,000 --> 00:01:36,000
>> ಆದರೆ ಹೆಚ್ಚು ಬಲವಾದ ಈಗ CS50 ಚೆಕ್ ಹೊಂದಿದೆ.

27
00:01:36,000 --> 00:01:39,000
CS50 ಚೆಕ್, ನೀವು ವಾಸ್ತವವಾಗಿ ಅದೇ ಸರಿಯಾಗಿವೆ ಪರೀಕ್ಷೆಗಳನ್ನು ಮಾಡಬಹುದು

28
00:01:39,000 --> 00:01:42,000
ಇತರ ಫೆಲೋಗಳು ಸಮರ್ಥವಾಗಿರುತ್ತವೆ ನಿಮ್ಮ ಸ್ವಂತ ಕೋಡ್ ರಂದು.

29
00:01:42,000 --> 00:01:44,000
ಈ ಉಪಕರಣಗಳಲ್ಲಿರುವ ಈಗ ಬರುವ ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಯುಕ್ತತೆಯಾಗಿದೆ

30
00:01:44,000 --> 00:01:46,000
ತಕ್ಷಣ ನೀವು ಪ್ರತಿ ಒಂದು update50 ಮಾಡುವಂತೆ

31
00:01:46,000 --> 00:01:49,000
pset 4 ವಿಶೇಷಣಗಳು, ಮತ್ತು ಇಂತಹ ಮೂಲಭೂತವಾಗಿ ಅದನ್ನು ಬಳಸಿ.

32
00:01:49,000 --> 00:01:51,000
ನೀವು ಆಜ್ಞೆಯನ್ನು check50 ರನ್.

33
00:01:51,000 --> 00:01:56,000
ನಂತರ ನೀವು ಒಂದು ಆಜ್ಞಾ ಸಾಲಿನ ವಾದದಲ್ಲಿನ ಹಾದು, ಅಥವಾ ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಸ್ವಿಚ್ ಅಥವಾ ಫ್ಲಾಗ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

34
00:01:56,000 --> 00:01:58,000
ಸಾಮಾನ್ಯವಾಗಿ, ವಿಭಜಿಸುವ ಚಿನ್ಹೆಗಳು ಹೊಂದಿರುವ ವಿಷಯಗಳ ಒಂದು ಸ್ವಿಚ್ ಕರೆಯಲಾಗುತ್ತದೆ

35
00:01:58,000 --> 00:02:02,000
ಆಜ್ಞಾ ಸಾಲಿನ ಪ್ರೋಗ್ರಾಂಗೆ, ಆದ್ದರಿಂದ ಸಿ ಸೂಚಿಸುತ್ತದೆ

36
00:02:02,000 --> 00:02:04,000
ನೀವು ಚಲಾಯಿಸಲು ಬಯಸುವ ಚೆಕ್.

37
00:02:04,000 --> 00:02:07,000
>> ನೀವು ಚಲಾಯಿಸಲು ಬಯಸುವ ಪರೀಕ್ಷೆಗಳು ಅನನ್ಯವಾಗಿ ಈ ಸ್ಟ್ರಿಂಗ್ ಗುರುತಿಸುತ್ತಾನೆ

38
00:02:07,000 --> 00:02:10,000
2012/pset4/resize.

39
00:02:10,000 --> 00:02:13,000
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಅದು ಕೇವಲ ಒಂದು ಕ್ರಮವಿಲ್ಲದ ಆದರೆ ಅನನ್ಯ STRING ರ

40
00:02:13,000 --> 00:02:18,000
ನಾವು ಅನನ್ಯವಾಗಿ pset 4 ನ ಸರಿಯಾಗಿವೆ ಪರೀಕ್ಷೆಗಳು ಗುರುತಿಸಲು ಬಳಸುವ.

41
00:02:18,000 --> 00:02:21,000
ತದನಂತರ ನೀವು ಅಪ್ಲೋಡ್ ಮಾಡಲು ಬಯಸುವ ಕಡತಗಳನ್ನು ಒಂದು ಜಾಗವನ್ನು ಪ್ರತ್ಯೇಕಿಸಿ ಪಟ್ಟಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು

42
00:02:21,000 --> 00:02:24,000
ವಿಶ್ಲೇಷಣೆಗೆ CS50 ಚೆಕ್ ಗೆ.

43
00:02:24,000 --> 00:02:29,000
ಉದಾಹರಣೆಗೆ, ನಾನು ಇಲ್ಲಿ ನನ್ನ ಪರಿಹಾರ ಹೋಗಿ ವೇಳೆ resize.c-

44
00:02:29,000 --> 00:02:31,000
ಅಂತ ದೊಡ್ಡ ಟರ್ಮಿನಲ್ ಕಿಟಕಿ ತೆರೆಯುತ್ತದೆ ಅವಕಾಶ

45
00:02:31,000 --> 00:02:42,000
ನಾನು ಮುಂದೆ ಹೋಗಿ ಈಗ ರನ್ check50-ಸಿ 2012/pset4/resize, ಸೇ

46
00:02:42,000 --> 00:02:46,000
ಆಗ ನಾನು, ಮುಂದೆ ಹೋಗಿ ಕಡತಗಳನ್ನು ಹೆಸರನ್ನು ಸೂಚಿಸಿ

47
00:02:46,000 --> 00:02:49,000
resize.c, ಮತ್ತು ನಂತರ, ಅದು ಸಂಕುಚಿತ ನಮೂದಿಸಿ ಹಿಟ್

48
00:02:49,000 --> 00:02:53,000
ಇದು ಅಪ್ಲೋಡ್ಗಳು, ಇದು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಮತ್ತು ನಾನು ಪರೀಕ್ಷೆಗಳ ಇಡೀ ಗುಂಪೇ ವಿಫಲವಾಗಿದೆ.

49
00:02:53,000 --> 00:02:59,000
ಮೇಲಿನ ಎಡಭಾಗದಲ್ಲಿ ಕೆಂಪು ಒಂದು resize.c ಮತ್ತು BMP ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಹೇಳುತ್ತದೆ.

50
00:02:59,000 --> 00:03:01,000
ಟೆಸ್ಟ್ ಆಗಿತ್ತು. ಎಂದು ನಾವು ಕೇಳಿದಾಗ ಪ್ರಶ್ನೆಯಾಗಿದೆ.

51
00:03:01,000 --> 00:03:04,000
ಉತ್ತರ ತಪ್ಪು ಕಾರಣ ಮತ್ತು ಅತೃಪ್ತಿ ಇಲ್ಲಿದೆ.

52
00:03:04,000 --> 00:03:08,000
ಇದು ಕೆಳಗೆ ಬಿಳಿ ಪಠ್ಯ ಅಸ್ತಿತ್ವ bmp.h ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ ಹೇಳುತ್ತಾರೆ, ಮತ್ತು ಕೇವಲ ನನ್ನ ತಪ್ಪು.

53
00:03:08,000 --> 00:03:11,000
, ನಾನು ಅಪ್ಲೋಡ್ ಮಾಡಲು ಮರೆತು, ಆದ್ದರಿಂದ ನಾನು ಎರಡೂ ಫೈಲ್ಗಳನ್ನು ಅಪ್ಲೋಡ್ ಮಾಡಬೇಕು

54
00:03:11,000 --> 00:03:14,000
resize.c ಮತ್ತು bmp.h.

55
00:03:14,000 --> 00:03:17,000
ಅವರು ಔಟ್ ಏಕೆಂದರೆ ಈಗ ಇತರ ಪರೀಕ್ಷೆಗಳು ಎಲ್ಲಾ ಹಳದಿ ನಲ್ಲಿ ಗಮನಕ್ಕೆ,

56
00:03:17,000 --> 00:03:21,000
ಅವರು ಎರಡೂ ಸಂತೋಷ ಅಥವಾ ದುಃಖ, ಏಕೆಂದರೆ ಹೀಗೆ ನಗು ಮುಖದ, ಲಂಬ

57
00:03:21,000 --> 00:03:25,000
ಆದರೆ ನಾವು ಆ ಚೆಕ್ ಔಟ್ ಕಾಣಿಸುತ್ತದೆ ಮೊದಲು ಕೆಂಪು ಆ ಸಮಸ್ಯೆಯನ್ನು ನಿವಾರಿಸುವಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ.

58
00:03:25,000 --> 00:03:27,000
>> ಈ ಸರಿಪಡಿಸಲು ಅವಕಾಶ.

59
00:03:27,000 --> 00:03:30,000
ಸಹ bmp.h ಜೊತೆಗೆ, ನನ್ನನ್ನು ಜೂಮ್ ಮತ್ತು ಈ ಮರುಪ್ರದರ್ಶನ ಈ ಬಾರಿ ಅವಕಾಶ

60
00:03:30,000 --> 00:03:34,000
ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಹೋದಲ್ಲಿ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ, ಈಗ ನಮೂದಿಸಿ, ಮತ್ತು

61
00:03:34,000 --> 00:03:38,000
ಇದು ನಿಮ್ಮ ತಡೆಹಿಡಿದು ಪರಿಣಾಮವಾಗಿ ಪರಿಶೀಲಿಸಿ ಮತ್ತು ನಂತರ ಮರಳಲು ವಿಶೇಷವೇನು ಉಸಿರಾಟದ-

62
00:03:38,000 --> 00:03:42,000
ನಾನು ಇದುವರೆಗೆ pset 4 ರಂದು ನಿಜವಾಗಿಯೂ ಚೆನ್ನಾಗಿ ನಾನು ಅಂದರೆ ಎಲ್ಲಾ ಹಸಿರು.

63
00:03:42,000 --> 00:03:44,000
ನೀವು ಇಲ್ಲಿ ನೋಡಿ ಮತ್ತು ಡಿಸ್ಕ್ರಿಪ್ಟಿವ್ ಬರಹ ನಿರ್ಣಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

64
00:03:44,000 --> 00:03:47,000
ನಾವು ಪರೀಕ್ಷೆ ಕರಾರುವಕ್ಕಾಗಿ ಏನು.

65
00:03:47,000 --> 00:03:49,000
ನಾವು ಮೊದಲ ಕಡತಗಳನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಪರೀಕ್ಷೆ?

66
00:03:49,000 --> 00:03:51,000
ನಾವು ನಂತರ resize.c ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ ಪರೀಕ್ಷೆ?

67
00:03:51,000 --> 00:03:58,000
ನಂತರ ನಾವು N, ಗಣಕತೆರೆ ಅಂಶವೆಂದರೆ 1 ಅದನ್ನು 1x1-ಪಿಕ್ಸೆಲ್ BMP ಗಾತ್ರ ಬದಲಾವಣೆ ಮಾಡುವುದಿಲ್ಲ ಪರೀಕ್ಷಿಸಲಾಯಿತು.

68
00:03:58,000 --> 00:04:01,000
ನೀವು N ಯಾವುದೇ ಕಲ್ಪನೆ ಇದ್ದರೆ ಈಗ, ನೀವು ಒಮ್ಮೆ, pset 4 ಆಗಿ ಧುಮುಕುವುದಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ

69
00:04:01,000 --> 00:04:04,000
ಆದರೆ ಕೇವಲ ನೀವು ಮರುಆಕಾರ ಅಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಒಂದು ವಿವೇಕದ ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ

70
00:04:04,000 --> 00:04:08,000
ಗಣಕತೆರೆ ಅಂಶ 1 ವೇಳೆ ಎಲ್ಲಾ ಒಂದು ಚಿತ್ರ.

71
00:04:08,000 --> 00:04:14,000
ತದ್ವಿರುದ್ಧವಾಗಿ, ಸರಿಯಾಗಿ 2x2 ಒಂದು 1x1 ಪಿಕ್ಸೆಲ್ BMP ಒಂದು 1x1 ಪಿಕ್ಸೆಲ್ resizes ವೇಳೆ

72
00:04:14,000 --> 00:04:19,000
N 2, ನಂತರ ಅದೇ ರೀತಿ, ಗಣಿ ಪ್ರಕಾರವಾಗಿ ರೂಪಿಸುತ್ತದೆ.

73
00:04:19,000 --> 00:04:22,000
>> ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಒಂದು ಉದ್ದೇಶವನ್ನು, ದಾಟುವ ಬೆರಳುಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು

74
00:04:22,000 --> 00:04:25,000
ನಿಮಗೆ ಮೊದಲು ಸಮೀಕರಣದ ನಿಮ್ಮ pset ಸಲ್ಲಿಸಿ.

75
00:04:25,000 --> 00:04:28,000
ನಿಮ್ಮ TF ಶೀಘ್ರದಲ್ಲೇ ತಿಳಿಯುವುದಿಲ್ಲ ನಿಖರವಾಗಿ ಎಂಬುದನ್ನು

76
00:04:28,000 --> 00:04:30,000
ನೀವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಸೆಟ್ ಕೆಲವು ಸಲ್ಲಿಸುವ ಬಗ್ಗೆ ಹೋದಂತೆ,

77
00:04:30,000 --> 00:04:34,000
ಮತ್ತು ಶೈಕ್ಷಣಿಕ ಪ್ರೇರಣೆ ಹಾಕಲು ನಿಜಕ್ಕೂ

78
00:04:34,000 --> 00:04:37,000
ನೀವು ಒಂದು ಪ್ರಿಯರಿ ತಿಳಿದಿದೆ ಆದ್ದರಿಂದ ನೀವು ಮುಂದೆ ಅವಕಾಶ

79
00:04:37,000 --> 00:04:39,000
ನಿಮ್ಮ ಕೋಡ್ ನ್ಯೂನತೆಗಳನ್ನು ಮತ್ತು ಹಾದುಹೋಗುತ್ತಿರುವ ಎಂದು ಪರೀಕ್ಷೆಗಳು ಇಲ್ಲ ಎಂದು

80
00:04:39,000 --> 00:04:43,000
ನೀವು ಆ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಮುಂದೆ ಅಪ್ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಸಮಯದಲ್ಲಿ ಹಾಕಬಹುದು

81
00:04:43,000 --> 00:04:45,000
ಅಂಕ ಕಳೆದುಕೊಳ್ಳುವ ಬದಲಿಗೆ, ನಿಮ್ಮ TF ಪ್ರತಿಕ್ರಿಯೆ ಪಡೆಯುವುದು

82
00:04:45,000 --> 00:04:48,000
ತದನಂತರ ನಾನು ಔಟ್ ಕಾಣಿಸಿಕೊಂಡಿತ್ತು ಹೊಂದಬೇಕಿತ್ತೊ ನಂತಹ ", Ahh", ಹೋಗಿ.

83
00:04:48,000 --> 00:04:50,000
ಈಗ ಕನಿಷ್ಠ ನೀವು ಸಹಾಯ ಸಾಧನವಾಗಿ ಇಲ್ಲ.

84
00:04:50,000 --> 00:04:52,000
ಇದು ದೋಷ ಅಲ್ಲಿ ಎತ್ತಿ ಹಿಂದಿರುಗಬಹುದೆಂದು, ಆದರೆ ನಿಮಗೆ ತಿಳಿಸುವರು

85
00:04:52,000 --> 00:04:54,000
ಇದನ್ನು ಲಕ್ಷಣವಾಗಿ ಏನು.

86
00:04:54,000 --> 00:04:57,000
>> ಈಗ ಪರೀಕ್ಷೆ ಅಗತ್ಯವಾಗಿ ಸಮಗ್ರ ಅಲ್ಲ ಅರ್ಥ.

87
00:04:57,000 --> 00:04:59,000
ನೀವು ಹಸಿರು ನಗು ಮುಖಗಳ ಪೂರ್ಣ ಸ್ಕ್ರೀನ್ ಪಡೆಯಲು ಕೇವಲ ಏಕೆಂದರೆ

88
00:04:59,000 --> 00:05:02,000
ನಿಮ್ಮ ಕೋಡ್ ಪರಿಪೂರ್ಣ ಎಂದಲ್ಲ, ಆದರೆ ಅರ್ಥವೇನು

89
00:05:02,000 --> 00:05:06,000
ಇದು ವಿಶೇಷ ಶಿಫಾರಸು ಕೆಲವು ಪರೀಕ್ಷೆಗಳನ್ನು ಪಾಸು ಎಂದು.

90
00:05:06,000 --> 00:05:08,000
ಕೆಲವೊಮ್ಮೆ ನಾವು ಚೆಕ್ ಬಿಡುಗಡೆ ಮಾಡುವುದಿಲ್ಲ.

91
00:05:08,000 --> 00:05:10,000
ಉದಾಹರಣೆಗೆ, ವೊಡುನಿಟ್, pset 4 ಅಂಶಗಳು ಒಂದು,

92
00:05:10,000 --> 00:05:15,000
ನಾವು ನಿರಾಶಾದಾಯಕ ರೀತಿಯ ನೀಡಲು ವೇಳೆ

93
00:05:15,000 --> 00:05:18,000
ಅದು ಯಾವುದು, ಮತ್ತು ಬಹಿರಂಗಪಡಿಸಲು ರೀತಿಯಲ್ಲಿ ಇಲ್ಲ ಎಂದು ಉತ್ತರ

94
00:05:18,000 --> 00:05:21,000
ವ್ಯಕ್ತಿ ಕೆಂಪು ಶಬ್ದ ರಲ್ಲಿ ಇವರು.

95
00:05:21,000 --> 00:05:24,000
ವಿಶೇಷ ಯಾವಾಗಲೂ pset 5 ಮುಂದುವರಿಯುವ ಭವಿಷ್ಯದಲ್ಲಿ ನಮೂದಿಸುತ್ತದೆ

96
00:05:24,000 --> 00:05:26,000
ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಪರಿಶೀಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು.

97
00:05:26,000 --> 00:05:28,000
ನೀವು ಕೆಳಗೆ ಈ ಬಿಳಿ URL ಇಲ್ಲ ಗಮನಕ್ಕೆ ಮಾಡುತ್ತೇವೆ.

98
00:05:28,000 --> 00:05:30,000
ಈಗ, ಈ ಕೇವಲ ರೋಗ ಉತ್ಪನ್ನ.

99
00:05:30,000 --> 00:05:33,000
ಆ URL ಗೆ ಭೇಟಿ ವೇಳೆ, ನೀವು ಕ್ರೇಜಿ, ರಹಸ್ಯ ಸಂದೇಶಗಳನ್ನು ಒಂದು ಇಡೀ ಗುಂಪೇ ಪಡೆಯುತ್ತೀರಿ

100
00:05:33,000 --> 00:05:36,000
ನೀವು ಮೂಲಕ ನೋಡಲು ಸ್ವಾಗತ ಕೋರುತ್ತೇವೆ, ಆದರೆ ಅದು ಸಿಬ್ಬಂದಿ ಹೆಚ್ಚಾಗಿ ಎಂದು

101
00:05:36,000 --> 00:05:41,000
ಆದ್ದರಿಂದ ನಾವು ನಿವಾರಿಸಲು ಮತ್ತು check50 ಸ್ವತಃ ದೋಷಗಳನ್ನು ದೋಷ ಎಂದು.

102
00:05:41,000 --> 00:05:46,000
>> ಸಡಗರ ಇಲ್ಲದೆ, ನಾವು ಆಫ್ ಬಿಟ್ಟು ಅಲ್ಲಿ ಮೇಲೆ ಚಲಿಸೋಣ.

103
00:05:46,000 --> 00:05:48,000
ಕೆಲವು ವಾರಗಳ ಕಾಲ ಲಘುವಾಗಿ ನಾವು ತೆಗೆದುಕೊಂಡ CS50 ಗ್ರಂಥಾಲಯ,

104
00:05:48,000 --> 00:05:52,000
ಆದರೆ ಕಳೆದ ವಾರ, ನಾವು ಪದರಗಳ ಒಂದು ಮರಳಿ ಸಿಪ್ಪೆಸುಲಿಯುವ ಆರಂಭಿಸಿದರು.

105
00:05:52,000 --> 00:05:55,000
ನಾವು ಬದಲಿಗೆ ಏನು ಪರವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಪಕ್ಕಕ್ಕೆ ಹಾಕುವ ಆರಂಭಿಸಿದರು?

106
00:05:55,000 --> 00:05:57,000
[ವಿದ್ಯಾರ್ಥಿಗಳು] ಚಾರ್.

107
00:05:57,000 --> 00:05:59,000
ಈ ಬಾರಿ ಒಂದು ಚಾರ್ * ಪ್ರಮುಖ ಚಾರ್ *,

108
00:05:59,000 --> 00:06:03,000
ಆದರೆ ಈಗ ನಾವು ನಿಜವಾದ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ಎಂದು ನಟಿಸುವುದು ಹೊಂದಿಲ್ಲ.

109
00:06:03,000 --> 00:06:06,000
ಬದಲಿಗೆ, ಇದು, ಚಾರ್ * ಫಾರ್ ಡೈವಸ್ಟೇಷನ್ ಒಂದು ಸಮಾನಾರ್ಥಕ ತೆಗೆದುಕೊಳ್ಳುತ್ತಿದ್ದರೆ

110
00:06:06,000 --> 00:06:09,000
ಮತ್ತು ಸ್ಟ್ರಿಂಗ್, ಪಾತ್ರಗಳ ಒಂದು ಅನುಕ್ರಮದ

111
00:06:09,000 --> 00:06:14,000
ಆದ್ದರಿಂದ ಚಾರ್ * ರು ಎಂದು ತಂತಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅರ್ಥ ಇಲ್ಲ?

112
00:06:14,000 --> 00:06:20,000
ಒಂದು ಚಾರ್ * ಸ್ಟ್ರಿಂಗ್ ಈ ಪರಿಕಲ್ಪನೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಏನು ನೀಡಬಲ್ಲದು?

113
00:06:20,000 --> 00:06:23,000
ಹೌದು. >> [ವಿದ್ಯಾರ್ಥಿ] ಮೊದಲ ಅಕ್ಷರ.

114
00:06:23,000 --> 00:06:25,000
ಉತ್ತಮ, ಮೊದಲ ಅಕ್ಷರ, ಆದರೆ ಸಾಕಷ್ಟು ಮೊದಲ ಅಕ್ಷರ.

115
00:06:25,000 --> 00:06:27,000
ಇದು [ವಿದ್ಯಾರ್ಥಿಗಳು] ವಿಳಾಸ ಇಲ್ಲಿದೆ.

116
00:06:27,000 --> 00:06:29,000
ಉತ್ತಮ, ಮೊದಲ ಪಾತ್ರದ ವಿಳಾಸಕ್ಕೆ.

117
00:06:29,000 --> 00:06:33,000
ಕಂಪ್ಯೂಟರ್ ನ ನೆನಪಿಗಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಪ್ರತಿನಿಧಿಸಲು ಎಲ್ಲರೂ

118
00:06:33,000 --> 00:06:36,000
ಕೇವಲ ಅದರ ಮೊದಲ ಬೈಟ್ ಅನನ್ಯ ವಿಳಾಸ.

119
00:06:36,000 --> 00:06:38,000
ನೀವು ಅದನ್ನು ಎಷ್ಟು ತಿಳಿಯಲು ಇಲ್ಲ

120
00:06:38,000 --> 00:06:42,000
ಹೇಗೆ ನೀವು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಎಂದು ಲೆಕ್ಕಾಚಾರ ಏಕೆಂದರೆ?

121
00:06:42,000 --> 00:06:44,000
[ವಿದ್ಯಾರ್ಥಿ] ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ.

122
00:06:44,000 --> 00:06:48,000
ನೀವು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ, ಅತ್ಯುತ್ತಮ, ಆದರೆ ಹೇಗೆ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಕರೆ ಮಾಡಬಹುದು?

123
00:06:48,000 --> 00:06:50,000
ಅದು ಏನು ಮಾಡುತ್ತದೆ? ಹೌದು.

124
00:06:50,000 --> 00:06:52,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಶೂನ್ಯಚಿಹ್ನೆ ಪಡೆಯಲು ತನಕ ಹೋಗಿ ಇರಿಸಿ.

125
00:06:52,000 --> 00:06:54,000
ಹೌದು, ನಿಖರವಾಗಿ, ಇದು ಕೇವಲ, ಆದರೆ ಲೂಪ್, ಲೂಪ್ ಒಂದು ಜೊತೆ iterates

126
00:06:54,000 --> 00:06:57,000
* ನಿಂದ ಕೊನೆಗೆ ಏನೇ, ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

127
00:06:57,000 --> 00:07:01,000
\ 0 ಮೂಲಕ ಎಂದು ಕರೆಯಲ್ಪಡುವ NUL ಪಾತ್ರ, NUL,

128
00:07:01,000 --> 00:07:05,000
ಒಂದು ಪಾಯಿಂಟರ್ ಇದು ಶೂನ್ಯ, ಜೊತೆಗೆ ಗೊಂದಲ

129
00:07:05,000 --> 00:07:07,000
ಇದು ಇಂದು ಮತ್ತೆ ಸಂವಾದ ಬರುತ್ತವೆ.

130
00:07:07,000 --> 00:07:11,000
>> ನಾವು ಮತ್ತೆ GetInt ಪದರವನ್ನು ಸುಲಿದ ಮತ್ತು ನಂತರ ನಾವು GetString ಒಂದು ನೋಟ ತೆಗೆದುಕೊಂಡಿತು

131
00:07:11,000 --> 00:07:14,000
ಮತ್ತು, ಆ ಕಾರ್ಯಗಳು ಎರಡೂ, ಅಥವಾ ನಿಜವಾಗಿಯೂ ಮರುಪಡೆಯಲು

132
00:07:14,000 --> 00:07:18,000
GetString, ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯದ ಬಳಸುತ್ತಿದ್ದರು

133
00:07:18,000 --> 00:07:21,000
ವಾಸ್ತವವಾಗಿ ಪಾರ್ಸ್ ಮಾಡಲು, ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಓದಲು ಅಥವಾ ವಿಶ್ಲೇಷಿಸಲು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.

134
00:07:21,000 --> 00:07:25,000
ಮತ್ತು ಹೊಸ ಕಾರ್ಯ ಯಾವುದು?

135
00:07:25,000 --> 00:07:27,000
Scanf ಅಥವಾ sscanf. ವಾಸ್ತವವಾಗಿ ಕೆಲವು ವಿಭಿನ್ನ ವೈಶಿಷ್ಟ್ಯಗಳಲ್ಲಿ ಬರುತ್ತದೆ.

136
00:07:27,000 --> 00:07:31,000
Scanf ಇಲ್ಲ, sscanf ಇಲ್ಲ, fscanf ಇಲ್ಲ.

137
00:07:31,000 --> 00:07:35,000
ಇದೀಗ, ಆದರೂ, ನ ಒಂದು ಅತ್ಯಂತ ಸುಲಭವಾಗಿ ಸಚಿತ್ರ ಗಮನ ಅವಕಾಶ

138
00:07:35,000 --> 00:07:38,000
ಮತ್ತು ನನಗೆ ಮುಂದುವರಿಯಿರಿ ಉಪಕರಣಗಳಲ್ಲಿರುವ ತೆರೆದುಕೊಳ್ಳಲು ಅವಕಾಶ

139
00:07:38,000 --> 00:07:41,000
ಈ ರೀತಿಯ ಕಡತ, scanf1.c.

140
00:07:41,000 --> 00:07:43,000
ಇದು, ಒಂದು ಸೂಪರ್ ಸರಳ ಕಾರ್ಯಕ್ರಮ

141
00:07:43,000 --> 00:07:46,000
ಆದರೆ ನಾವು ಅದನ್ನು ಎಂದಿಗೂ ನೀವು ಏನಾದರೂ ಮಾಡುತ್ತಾನೆ

142
00:07:46,000 --> 00:07:48,000
CS50 ಗ್ರಂಥಲಯದ ಸಹಾಯವಿಲ್ಲದೆ.

143
00:07:48,000 --> 00:07:51,000
ಬಳಕೆದಾರರ ಒಂದು ಇಂಟ್ ಪಡೆಯುತ್ತದೆ. ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

144
00:07:51,000 --> 00:07:53,000
ಅಲ್ಲದೆ, ಸರಣಿಯನ್ನು 16 ರಲ್ಲಿ,

145
00:07:53,000 --> 00:07:56,000
ನಾವು ಒಂದು ಇಂಟ್ ಎಂಬ X ಘೋಷಿಸುವಂತೆ ಗಮನಿಸಿ, ಕಥೆ ಈ ಹಂತದಲ್ಲಿ,

146
00:07:56,000 --> 00:07:58,000
x ನ ಮೌಲ್ಯವನ್ನು ಏನು?

147
00:07:58,000 --> 00:08:00,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

148
00:08:00,000 --> 00:08:02,000
[ಡೇವಿಡ್ ಎಂ] ರೈಟ್, ತಿಳಿದಿರುವ, ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯವನ್ನು ಸಂಭಾವ್ಯವಾಗಿ, ಆದ್ದರಿಂದ 17 ರಲ್ಲಿ, ನಾವು ಬಳಕೆದಾರರು ತಿಳಿಸಿ

149
00:08:02,000 --> 00:08:06,000
ದಯವಿಟ್ಟು ನನ್ನನ್ನು ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ನೀಡುತ್ತದೆ, ಮತ್ತು ಇದು ಕುತೂಹಲಕಾರಿ ಗೆಟ್ಸ್ ಅಲ್ಲಿ ಹಂತದ 18 ಆಗಿದೆ.

150
00:08:06,000 --> 00:08:11,000
Scanf ಅದನ್ನು ಉದ್ಧರಣ ಈ ರೂಪದಲ್ಲಿ ಸಂಕೇತಗಳು ಬಳಸುವ ರಲ್ಲಿ printf ಒಂದು ಕಲ್ಪನೆಯನ್ನು ಎರವಲು ತೋರುತ್ತದೆ.

151
00:08:11,000 --> 00:08:13,000
% D ಕೋರ್ಸ್ ಒಂದು ದಶಮಾಂಶ ಸಂಖ್ಯೆ.

152
00:08:13,000 --> 00:08:21,000
ಆದರೆ ಏಕೆ ಮತ್ತು X ಬದಲಿಗೆ ಕೇವಲ X ಸಾಗುವ ನಾನು?

153
00:08:21,000 --> 00:08:24,000
ಮಾಜಿ ಸರಿಯಾಗಿದೆ. ಹೌದು.

154
00:08:24,000 --> 00:08:26,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

155
00:08:26,000 --> 00:08:31,000
ನಿಖರವಾಗಿ, ಈ ಕಾರ್ಯಕ್ರಮದ ಗುರಿ, ಫಂಕ್ಷನ್ GetInt ಸ್ವತಃ ನಂತಹ

156
00:08:31,000 --> 00:08:34,000
ಬಳಕೆದಾರರ ಒಂದು ಇಂಟ್ ಪಡೆಯಲು ನಾನು ಕಾರ್ಯಗಳನ್ನು ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ ಇದೆ

157
00:08:34,000 --> 00:08:38,000
ಎಲ್ಲಾ ಅಸ್ಥಿರ ನಾನು ಬಯಸುತ್ತೇನೆ, ಆದರೆ ನಾನು ಉಲ್ಲೇಖ ಮೂಲಕ ಹಾದು ಹೋದರೆ

158
00:08:38,000 --> 00:08:41,000
ಅಥವಾ ಪಾಯಿಂಟರ್ ವಿಳಾಸಕ್ಕೆ ಮೂಲಕ ಅಥವಾ, ಇಂದಿನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಎಲ್ಲಾ ಪರ್ಯಾಯ

159
00:08:41,000 --> 00:08:46,000
ನಂತರ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವೇರಿಯಬಲ್ ವಿಷಯಗಳನ್ನು ಬದಲಾಯಿಸಲು ಯಾವುದೇ ಸಾಮರ್ಥ್ಯವನ್ನು ಹೊಂದಿದೆ.

160
00:08:46,000 --> 00:08:49,000
ಈ ಕೇವಲ ಸ್ವಾಪ್ ನ ದೋಷಯುಕ್ತ ಆವೃತ್ತಿ ಒಂದು ನಕಲು ಸಾಗುತ್ತದೆ

161
00:08:49,000 --> 00:08:51,000
ನಾವು ಈಗ ಕೆಲವು ಬಾರಿ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ನೀವು.

162
00:08:51,000 --> 00:08:54,000
>> ಆದರೆ, ಏನು & X ಮೂಲಕ, ನಾನು ಅಕ್ಷರಶಃ ಏನು ಹಾದುಹೋಗುವ ನಾನು?

163
00:08:54,000 --> 00:08:57,000
[ವಿದ್ಯಾರ್ಥಿ] ವಿಳಾಸಕ್ಕೆ. X ನ ವಿಳಾಸಕ್ಕೆ >>.

164
00:08:57,000 --> 00:09:01,000
ಇದು scanf ಎಂಬ ಕ್ರಿಯೆಯ ಒಂದು ನಕ್ಷೆ ರೇಖಾಚಿತ್ರ ಮತ್ತು ಇಲ್ಲಿ ಹೇಳುವ ರೀತಿಯಲ್ಲಿ

165
00:09:01,000 --> 00:09:04,000
ಈ ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿ ಒಂದು ಚಂಕ್ ನಿರ್ದೇಶನಗಳನ್ನು ಗಳು

166
00:09:04,000 --> 00:09:07,000
ನೀವು ಕೆಲವು ಪೂರ್ಣಾಂಕ ಶೇಖರಿಸಿಡಲು ಹೋಗಿ ಎಂದು

167
00:09:07,000 --> 00:09:10,000
ಕ್ರಮದಲ್ಲಿ sscanf ಈಗ ಮಾಡಲು

168
00:09:10,000 --> 00:09:13,000
ಯಾವ ಆಯೋಜಕರು, ವಾಕ್ಯ ಯಾವ ಕಾಯಿಯನ್ನು ಅದು ಬಳಸಲು ಮಾಡಲಿಕ್ಕೆ ಇದೆ

169
00:09:13,000 --> 00:09:19,000
ಬೇರೆಯವರು ಈ ಕಾರ್ಯವನ್ನು ಬರೆದದ್ದರಿಂದ ನಾವು ನೋಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಸಹ?

170
00:09:19,000 --> 00:09:21,000
ಅರ್ಥಾತ್ - ಆ ಬಗ್ಗೆ?

171
00:09:21,000 --> 00:09:23,000
[ವಿದ್ಯಾರ್ಥಿ] ಎಕ್ಸ್ ಓದಲು.

172
00:09:23,000 --> 00:09:27,000
ಕೆಲವು ಓದುವಿಕೆ ಎಂದು ಹೋಗುವ, ಆದರೆ ಇಲ್ಲಿ X ಸಂಬಂಧಿಸಿದಂತೆ ನ.

173
00:09:27,000 --> 00:09:30,000
Scanf x ನ ವಿಳಾಸಕ್ಕೆ ಅಂಗೀಕಾರವಾದ ಇದೆ ವೇಳೆ,

174
00:09:30,000 --> 00:09:35,000
syntactically, ಏನು ಆಯೋಜಕರು ಎಲ್ಲೋ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ತಲುಪಿದೆ

175
00:09:35,000 --> 00:09:38,000
ಒಳಗೆ scanf ನ ಅನುಷ್ಠಾನದ ಎಷ್ಟು scanf

176
00:09:38,000 --> 00:09:42,000
ವಾಸ್ತವವಾಗಿ ಆ ವಿಳಾಸಕ್ಕೆ ಹಲವಾರು 2 ಬರೆಯಬಹುದು?

177
00:09:42,000 --> 00:09:44,000
ಹೌದು, ಆದ್ದರಿಂದ *.

178
00:09:44,000 --> 00:09:47,000
* ಮೂಲಭೂತವಾಗಿ ಅಲ್ಲಿಗೆ ಹೋಗಿ ಅಂದರೆ ನಮ್ಮ dereference ಆಯೋಜಕರು, ಎಂದು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

179
00:09:47,000 --> 00:09:50,000
>> ಕೇಸ್ ಇಲ್ಲಿ ಹೊಂದಿದೆ ಎಂದು ಒಮ್ಮೆ, ಒಂದು ವಿಳಾಸಕ್ಕೆ ಹಸ್ತಾಂತರಿಸಲ್ಪಟ್ಟಿಲ್ಲ ನೀವು

180
00:09:50,000 --> 00:09:53,000
scanf ನಾವು ವಾಸ್ತವವಾಗಿ ಅದರ ಮೂಲ ಸುಮಾರು ನೋಡಿಕೊಳ್ಳುತ್ತಾರೆ ಬಹುಶಃ-ವೇಳೆ ಕೋಡ್-

181
00:09:53,000 --> 00:09:59,000
* X ಅಥವಾ ವಾಸ್ತವವಾಗಿ ಆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ಮತ್ತು ಅಲ್ಲಿ ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಹಾಕಲು ಸಮಾನ ನಡೆಸುತ್ತಿರುತ್ತಾನೆ.

182
00:09:59,000 --> 00:10:02,000
ಈಗ, ಮಾಹಿತಿ scanf ಕೀಬೋರ್ಡ್ ಸೂಚನೆಗಳನ್ನು ಪಡೆಯುತ್ತದೆ ಹೇಗೆ,

183
00:10:02,000 --> 00:10:04,000
ಇಂದು ನಾವು ನಮ್ಮ ಕೈಗಳನ್ನು ಔಟ್ ಅಲೆಗಳ ಮಾಡುತ್ತೇವೆ.

184
00:10:04,000 --> 00:10:07,000
ಕೇವಲ ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಮಾತನಾಡಲು sscanf ಅನುಮತಿಸುವ ಊಹಿಸುತ್ತವೆ

185
00:10:07,000 --> 00:10:11,000
ಬಳಕೆದಾರರ ಕೀಬೋರ್ಡ್, ಆದರೆ ಈಗ ಸಾಲು 19 ರಲ್ಲಿ ಈ ಹಂತದಲ್ಲಿ,

186
00:10:11,000 --> 00:10:14,000
ನಾವು ಕೇವಲ X ಮುದ್ರಿಸುತ್ತದೆ, ಆ ಸಂದರ್ಭದಲ್ಲಿ ತೋರುತ್ತದೆ

187
00:10:14,000 --> 00:10:17,000
ಆ scanf X ಒಂದು ಇಂಟ್ ಮಾಡಿತು.

188
00:10:17,000 --> 00:10:19,000
ಕರಾರುವಾಕ್ಕಾಗಿ scanf ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಕಳೆದ ವಾರ ಮರುಪಡೆಯಲು

189
00:10:19,000 --> 00:10:25,000
ಆ ಸ್ ಎಂಬುದನ್ನು GetString ಮತ್ತು GetInt ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ತನ್ನ ಕುಟುಂಬದ ಇತರ

190
00:10:25,000 --> 00:10:28,000
ಅಂತಿಮವಾಗಿ, sscanf ಹಾಗೆ ಸ್ವಲ್ಪ ಭಿನ್ನಾಭಿಪ್ರಾಯ ಆದರೂ ಕೆಲಸ

191
00:10:28,000 --> 00:10:31,000
ಇದು ಬದಲಿಗೆ ಕೀಬೋರ್ಡ್ ಒಂದು ಸರಣಿಯನ್ನು ಸ್ಕ್ಯಾನ್ ಎಂದರ್ಥ.

192
00:10:31,000 --> 00:10:33,000
ಆದರೆ ಈ ಒಂದು ಸಣ್ಣ ಭಿನ್ನಾಭಿಪ್ರಾಯ ಒಂದು ಅವಲೋಕಿಸೋಣ.

193
00:10:33,000 --> 00:10:37,000
Scanf2 ರಲ್ಲಿ, ನಾನು ನಿಜವಾಗಿ ಸ್ಕ್ರೆವೆದ್.

194
00:10:37,000 --> 00:10:42,000
ಯಾವುದು ತಪ್ಪು ಮತ್ತು ನಾನು ವಿವರಿಸುತ್ತದೆ ಎಂದು ಹೆಚ್ಚು ಕಾಮೆಂಟ್ ಮರೆಮಾಡಲು ವಿಲ್

195
00:10:42,000 --> 00:10:47,000
ಆವೃತ್ತಿ 2, ಈ ಕಾರ್ಯಕ್ರಮವು ಏನು ತಪ್ಪು?

196
00:10:47,000 --> 00:10:55,000
ಈ ಬಾರಿ ಸಾಧ್ಯವಾದಷ್ಟು ತಾಂತ್ರಿಕ ಬಿ.

197
00:10:55,000 --> 00:10:57,000
ಇದು ಬಹಳ ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತದೆ.

198
00:10:57,000 --> 00:11:03,000
ಇದು ಚೆನ್ನಾಗಿ ಇಂಡೆಂಟ್, ಆದರೆ ನ

199
00:11:03,000 --> 00:11:07,000
ಸರಿ, ಹೇಗೆ ಅವರ ಕಡಿಮೆ ಪ್ರಶ್ನೆಗಳಿಗೆ ಅದನ್ನು ಕತ್ತರಿಸು ಅವಕಾಶ?

200
00:11:07,000 --> 00:11:17,000
ಸಾಲು 16. ನಿಖರ ಆದರೆ ತಾಂತ್ರಿಕ ಇಂಗ್ಲೀಷ್ ಮಾಡುತ್ತಾ ಸಾಲಿನ 16 ಯಾವುದು?

201
00:11:17,000 --> 00:11:20,000
ಸ್ವಲ್ಪ ವಿಚಿತ್ರವಾಗಿ ಪಡೆಯಲಾಗುತ್ತಿದೆ. ಹೌದು, ಮೈಕೆಲ್.

202
00:11:20,000 --> 00:11:25,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಒಂದು ವಾಕ್ಯವನ್ನು ಮೊದಲ ಅಕ್ಷರವನ್ನು ಸೂಚಿಸುವ ನ.

203
00:11:25,000 --> 00:11:27,000
>> ಸರಿ, ಆಪ್ತ. ನನ್ನನ್ನು ಸ್ವಲ್ಪ ಒತ್ತಾಯ ಲೆಟ್.

204
00:11:27,000 --> 00:11:33,000
ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಅಕ್ಷರದ ತೋರಿಸುತ್ತಾ, ನೀವು ವೇರಿಯಬಲ್ ಎಂಬ ಬಫರ್ ಘೋಷಿಸುವವರಿಗೆ

205
00:11:33,000 --> 00:11:36,000
ಎಂದು, ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ವಿಳಾಸಕ್ಕೆ ಬೆಟ್ಟು ಕಾಣಿಸುತ್ತದೆ

206
00:11:36,000 --> 00:11:39,000
ಅಥವಾ ಬದಲಿಗೆ, ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ ಒಂದು ಚಾರ್ ಬೆಟ್ಟು ಕಾಣಿಸುತ್ತದೆ.

207
00:11:39,000 --> 00:11:42,000
ಯಾವುದೇ ಹುದ್ದೆ ಆಯೋಜಕರು ಇರುವುದರಿಂದ ಇದು ವಾಸ್ತವವಾಗಿ ಎಲ್ಲೆಡೆ ತೋರುಗಡ್ಡಿ ದೊರೆಯದಿದ್ದಲ್ಲಿ ಗಮನಿಸಿ.

208
00:11:42,000 --> 00:11:46,000
ಯಾವುದೇ ಸಮ ಚಿಹ್ನೆ ಇಲ್ಲ, ನಾವು ಮಾಡುತ್ತಿರುವುದು ಎಲ್ಲಾ ವೇರಿಯಬಲ್ ಕರೆಯಲ್ಪಡುವ ಬಫರ್ ಹಂಚುತ್ತಾರೆ ಆದ್ದರಿಂದ.

209
00:11:46,000 --> 00:11:49,000
ಇದು ಒಂದು ಪಾಯಿಂಟರ್ ಏಕೆಂದರೆ ಇದು, 32 ಬಿಟ್ಗಳು ಮನೆಯಿದ್ದ

210
00:11:49,000 --> 00:11:52,000
ಮತ್ತು ಬಫರ್ ವಿಷಯಗಳನ್ನು ಸಂಭಾವ್ಯವಾಗಿ ಅಂತಿಮವಾಗಿ

211
00:11:52,000 --> 00:11:57,000
ಒಂದು ಹಾಳೆಯನ್ನು ಒಂದು ವಿಳಾಸಕ್ಕೆ ಹೊಂದಿರುತ್ತವೆ, ಆದರೆ ಈಗ, ಬಫರ್ ಏನನ್ನು ಒಳಗೊಂಡಿದೆ?

212
00:11:57,000 --> 00:11:59,000
ಕೆಲವು ನಕಲಿ, ತಿಳಿದಿರುವ, ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯ,

213
00:11:59,000 --> 00:12:03,000
ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಏಕೆಂದರೆ, ಆದ್ದರಿಂದ ನಾವು ಏನು ಊಹಿಸುತ್ತವೆ ಮಾಡಬಾರದು.

214
00:12:03,000 --> 00:12:06,000
ಸರಿ, ಈಗ ಲೈನ್ 17-ಏನು ಇದೆ ಸಾಲಿನಲ್ಲಿ 17 ಮಾಡುತ್ತದೆ?

215
00:12:06,000 --> 00:12:08,000
ಬಹುಶಃ ಈ ಬೆಚ್ಚಗಾಗಲು ಕಾಣಿಸುತ್ತದೆ.

216
00:12:08,000 --> 00:12:10,000
ಅದು ಸರಿ, ಒಂದು ಸಾಲನ್ನು ತೋರಿಸುತ್ತದೆ?

217
00:12:10,000 --> 00:12:12,000
ಇದು ಸ್ಟ್ರಿಂಗ್ ದಯವಿಟ್ಟು ಮುದ್ರಿಸುತ್ತದೆ.

218
00:12:12,000 --> 00:12:15,000
>> ಲೈನ್ 18 ನಾವು ಈ ಒಂದು ಭಿನ್ನಾಭಿಪ್ರಾಯ ಕಂಡಿತು ಈಗ ಚಿರಪರಿಚಿತವಾದ ರೀತಿಯ

219
00:12:15,000 --> 00:12:18,000
ಆದರೆ ಬೇರೆ ರೂಪದಲ್ಲಿ ಕೋಡ್, ಹೀಗೆ ಸಾಲು 18 ರಲ್ಲಿ,

220
00:12:18,000 --> 00:12:23,000
ನಾವು ಇಲ್ಲಿ scanf ಹೇಳುತಿದ್ದಾರೆ ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್ ವಿಳಾಸವನ್ನು ಹೊಂದಿದೆ.

221
00:12:23,000 --> 00:12:27,000
ನಾನು, ನೀವು% ರು ಸೂಚಿಸುವ, ಸ್ಟ್ರಿಂಗ್ ರಿಂಗ್ ಬಯಸುವ

222
00:12:27,000 --> 00:12:32,000
ಆದರೆ ಸಮಸ್ಯೆಯನ್ನು ನಾವು ಇಲ್ಲಿ ವಿಷಯಗಳನ್ನು ಒಂದೆರಡು ಮಾಡದಿದ್ದರೆ ಎಂದು.

223
00:12:32,000 --> 00:12:35,000
ಸಮಸ್ಯೆಗಳ ಒಂದು ಯಾವುದು?

224
00:12:35,000 --> 00:12:38,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು dereference ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ನ.

225
00:12:38,000 --> 00:12:41,000
ಗುಡ್, ಶೂನ್ಯ ಅಥವಾ ಅನ್ಯಥಾ ಅಪರಿಚಿತ ಪಾಯಿಂಟರ್ಸ್.

226
00:12:41,000 --> 00:12:45,000
ನೀವು scanf ವಿಳಾಸವನ್ನು ಹಸ್ತಾಂತರಿಸುವ, ನೀವು ಕೇವಲ ಒಂದು ಕ್ಷಣ ಹಿಂದೆ ಹೇಳಿದರು

227
00:12:45,000 --> 00:12:49,000
ನಾವು ನಿಜವಾಗಿ ಏನು ಅದನ್ನು ನಿಗದಿಪಡಿಸಬಹುದು ಕಾರಣ ಎಂದು ವಿಳಾಸಕ್ಕೆ ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯ ಎಂದು

228
00:12:49,000 --> 00:12:53,000
ಆದ್ದರಿಂದ ನೀವು scanf ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಪುಟ್ ಹೋಗಿ ಹೇಳುತಿದ್ದಾರೆ

229
00:12:53,000 --> 00:12:56,000
ಇಲ್ಲಿ ಇನ್ನೂ ಅಲ್ಲಿ ಆದರೆ, ಗೊತ್ತಿಲ್ಲ

230
00:12:56,000 --> 00:12:59,000
ಆದ್ದರಿಂದ ನಾವು ವಾಸ್ತವವಾಗಿ ಬಫರ್ ಮೆಮೊರಿಯನ್ನು ಹಂಚಿಕೆ ಮಾಡಿಲ್ಲ.

231
00:12:59,000 --> 00:13:03,000
ಅಲ್ಲದೆ, ನೀವು ಸಹ scanf ಹೇಳುವ ಸಹ ಯಾವುವು?

232
00:13:03,000 --> 00:13:06,000
ಈ ಮೆಮೊರಿಯ ಒಂದು ಪಡೆ, ಮತ್ತು ಇದು, ಒಂದು ಕಸದ ಮೌಲ್ಯವಲ್ಲ ಪಕ್ಷದಲ್ಲಿ

233
00:13:06,000 --> 00:13:09,000
ಆದರೆ ನೀವು ಇನ್ನೂ scanf ಮುಖ್ಯವಾಗುತ್ತವೆ ಹೇಳುವುದು ಇಲ್ಲ.

234
00:13:09,000 --> 00:13:12,000
[ವಿದ್ಯಾರ್ಥಿ] ನಿಜವಾಗಿ ಎಲ್ಲಿ, ವನ್ನಾಗಲಿ.

235
00:13:12,000 --> 00:13:15,000
ವನ್ನಾಗಲಿ, ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಸರಿಯಾಗಿಯೆ.

236
00:13:15,000 --> 00:13:18,000
ಬಫರ್ ಈಗಾಗಲೇ ಪಾಯಿಂಟರ್ ಎಂದು ಘೋಷಿಸಿದರು ಏಕೆಂದರೆ

237
00:13:18,000 --> 00:13:22,000
ವಾಕ್ಯ * ತುಣುಕಿನೊಂದಿಗೆ, ನಾವು ವನ್ನಾಗಲಿ ಬಳಸಲು ಅಗತ್ಯವಿಲ್ಲ

238
00:13:22,000 --> 00:13:25,000
ಏಕೆಂದರೆ ಅದು ಈಗಾಗಲೇ ವಿಳಾಸಕ್ಕೆ, ಆದರೆ ನಾನು ಇಲ್ಲಿ ಕೇಳಿ ಭಾವಿಸುತ್ತೇನೆ.

239
00:13:25,000 --> 00:13:27,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಹೇಗೆ ದೊಡ್ಡದಾಗಿದೆ?

240
00:13:27,000 --> 00:13:29,000
ಉತ್ತಮ, ನಾವು, ಈ ಬಫರ್ ಎಷ್ಟು ದೊಡ್ಡ scanf ಹೇಳುವುದು ಇಲ್ಲ

241
00:13:29,000 --> 00:13:32,000
ಇದು ಬಫರ್ ಒಂದು ಪಾಯಿಂಟರ್ ಸಹ ವೇಳೆ ಅರ್ಥ

242
00:13:32,000 --> 00:13:35,000
ನಾವು, scanf ಹೇಳುವ ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಪುಟ್ ನೀವು

243
00:13:35,000 --> 00:13:38,000
ಆದರೆ ಇಲ್ಲಿ 2 ಬೈಟ್ಗಳು ಆಗಿರಬಹುದು, ಇದು 10 ಬೈಟ್ಗಳು, ಇದಕ್ಕೆ ಒಂದು ಮೆಗಾಬೈಟ್ ಆಗಿರಬಹುದು.

244
00:13:38,000 --> 00:13:41,000
Scanf ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಈ ಮೆಮೊರಿಯ ಒಂದು ಪಡೆ ಕಾರಣ

245
00:13:41,000 --> 00:13:43,000
ಬಹುಶಃ, ಇದು ಇನ್ನೂ ಒಂದು ಸಾಲನ್ನು ಅಲ್ಲ.

246
00:13:43,000 --> 00:13:48,000
ನೀವು ಪಾತ್ರಗಳು ಮತ್ತು ಮೆಮೊರಿಯ ಎಂದು ಚಂಕ್ ಒಂದು \ 0 ಬರೆಯಲು ಒಮ್ಮೆ ಕೇವಲ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ನ.

247
00:13:48,000 --> 00:13:51,000
ಈಗ ಅದು ಕೇವಲ ಮೆಮೊರಿ ಕೆಲವು ಚಂಕ್ ಇಲ್ಲಿದೆ.

248
00:13:51,000 --> 00:13:55,000
Scanf ಆ ವಿಳಾಸಕ್ಕೆ ಬರೆಯಲು ನಿಲ್ಲಿಸಲು ಯಾವಾಗ ಆಗುವುದಿಲ್ಲ.

249
00:13:55,000 --> 00:13:59,000
>> ನೀವು ನಾನು ಯಾದೃಚ್ಛಿಕವಾಗಿ ಕೀಲಿಮಣೆಯಲ್ಲಿ ಟೈಪಿಸಿದ ಅಲ್ಲಿ ಕಳೆದ ಕೆಲವು ಉದಾಹರಣೆಗಳು ನೆನಪಿಗೆ ವೇಳೆ

250
00:13:59,000 --> 00:14:03,000
ಉಕ್ಕಿ ಒಂದು ಬಫರ್ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ, ಮತ್ತು ನಾವು ನಿಖರವಾಗಿ ಬಗ್ಗೆ ಶುಕ್ರವಾರ ಮಾತನಾಡಿದರು.

251
00:14:03,000 --> 00:14:07,000
ಪ್ರತಿಕೂಲ ಹೇಗಾದರೂ ನಿಮ್ಮ ಯೋಜನೆಗಳ ಬಗ್ಗೆ ಬಹಳ ದೊಡ್ಡ ಪದ ಚುಚ್ಚಿಕೊಂಡು ವೇಳೆ

252
00:14:07,000 --> 00:14:10,000
ಅಥವಾ ವಾಕ್ಯ ಅಥವಾ ಪದಗುಚ್ಛದ ನಂತರ ನೀವು ತುಂಬಿರುವುದರಿಂದ ಮಾಡಬಹುದು ನಿರೀಕ್ಷಿಸುತ್ತಿರುವುದಾಗಿ

253
00:14:10,000 --> 00:14:13,000
ಕೆಟ್ಟ ಪರಿಣಾಮಗಳನ್ನು ಇದು ಮೆಮೊರಿ ಒಂದು ಪಡೆ,

254
00:14:13,000 --> 00:14:15,000
ಇಡೀ ಪ್ರೋಗ್ರಾಮ್ ತೆಗೆದುಕೊಳ್ಳುವ ಹಾಗೆ.

255
00:14:15,000 --> 00:14:17,000
ನಾವು ಹೇಗಾದರೂ ಈ ಸರಿಪಡಿಸಲು ಅಗತ್ಯವಿದೆ.

256
00:14:17,000 --> 00:14:20,000
ನನ್ನನ್ನು ಜೂಮ್ ಮತ್ತು ಈ ಕಾರ್ಯಕ್ರಮದ ಆವೃತ್ತಿ 3 ಹೋಗಲು ಅವಕಾಶ.

257
00:14:20,000 --> 00:14:22,000
ಒಂದು ಸ್ವಲ್ಪ ಉತ್ತಮ.

258
00:14:22,000 --> 00:14:24,000
ಈ ಆವೃತ್ತಿಯಲ್ಲಿ, ವ್ಯತ್ಯಾಸವನ್ನು ಗಮನಿಸಬಹುದು.

259
00:14:24,000 --> 00:14:27,000
ಸಾಲು 16 ರಲ್ಲಿ, ನಾನು ಮತ್ತೆ, ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂಬ ಬಫರ್ ಘೋಷಿಸುವ ನಾನು

260
00:14:27,000 --> 00:14:29,000
ಆದರೆ ಈಗ ಏನು?

261
00:14:29,000 --> 00:14:33,000
ಇದು 16 ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ.

262
00:14:33,000 --> 00:14:36,000
ನಾನು ಈಗ scanf ಹೇಳಬಹುದು ಇದರರ್ಥ ಈ ಉತ್ತಮ

263
00:14:36,000 --> 00:14:39,000
ಇಲ್ಲಿ ಮೆಮೊರಿಯ ನೈಜ ಪಾಲನ್ನು ಹೊಂದಿದೆ.

264
00:14:39,000 --> 00:14:42,000
ನೀವು ಬಹುತೇಕ ಈಗ ಪಾಯಿಂಟರ್ಸ್ ಎಂದು ಸರಣಿಗಳ ನಗರದ

265
00:14:42,000 --> 00:14:44,000
ವಾಸ್ತವವಾಗಿ ಸಮಾನ ಇಲ್ಲ ಕೂಡ.

266
00:14:44,000 --> 00:14:47,000
ವಿವಿಧ ಸಂದರ್ಭಗಳಲ್ಲಿ ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸುತ್ತದೆ ಮಾಡುತ್ತೇವೆ.

267
00:14:47,000 --> 00:14:50,000
ಆದರೆ ಖಚಿತವಾಗಿ ಬಫರ್ ಉಲ್ಲೇಖಿಸುತ್ತಿದ್ದಾರೆ ಕೇಸ್

268
00:14:50,000 --> 00:14:53,000
16 ಸಮೀಪದ ಅಕ್ಷರಗಳನ್ನು ಎಂದು ಏನನ್ನು ವ್ಯೂಹದ ಕಾರಣ

269
00:14:53,000 --> 00:14:55,000
ಈಗ ಕೆಲವು ವಾರಗಳ ಕಾಲ ಬಂದಿದೆ.

270
00:14:55,000 --> 00:14:59,000
>> ಇಲ್ಲಿ, ನಾನು ಇಲ್ಲಿ scanf ಹೇಳುವ ನಾನು ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್ ಇಲ್ಲಿದೆ.

271
00:14:59,000 --> 00:15:01,000
ಈ ಬಾರಿ ಅದು, ವಾಸ್ತವವಾಗಿ ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್ ಇಲ್ಲಿದೆ

272
00:15:01,000 --> 00:15:07,000
ಆದರೆ ಏಕೆ ಈ ಕಾರ್ಯಕ್ರಮವನ್ನು ಈಗಲೂ ಶೋಷಿಸುವ ಹೊಂದಿದೆ?

273
00:15:07,000 --> 00:15:11,000
ಇನ್ನೂ ತಪ್ಪು ಏನು?

274
00:15:11,000 --> 00:15:14,000
ನನ್ನ 16 ಬೈಟ್ಗಳು ಆದರೆ ನೀಡಲು ಹೇಳುತ್ತಿದ್ದೆ

275
00:15:14,000 --> 00:15:16,000
[ವಿದ್ಯಾರ್ಥಿ] ವಾಟ್ ಅವರು ಹೆಚ್ಚು 16 ಟೈಪ್ ವೇಳೆ?

276
00:15:16,000 --> 00:15:20,000
ನಿಖರವಾಗಿ ಯಾವ 17 ಅಕ್ಷರಗಳು ಅಥವಾ 1700 ಪಾತ್ರಗಳು ಬಳಕೆದಾರ ರೀತಿಯ ವೇಳೆ?

277
00:15:20,000 --> 00:15:23,000
ವಾಸ್ತವವಾಗಿ, ಈಗ ನಾವು ಈ ತಪ್ಪು ಮೇಲೆ ಟ್ರಿಪ್ ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನೋಡೋಣ.

278
00:15:23,000 --> 00:15:25,000
ಇದು ಉತ್ತಮ ಆದರೆ ಪರಿಪೂರ್ಣ ಅಲ್ಲ.

279
00:15:25,000 --> 00:15:28,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಪ್ರೋಗ್ರಾಂ ಸಂಕಲಿಸಲು scanf3 ಮಾಡಲು ಔಟ್ ಲೆಟ್.

280
00:15:28,000 --> 00:15:34,000
ಹಲೋ, ನಾವು ಸರಿ ಎಂದು ತೋರುತ್ತದೆ: ಸ್ಟ್ರಿಂಗ್, ನನಗೆ scanf3 ರನ್ ದಯವಿಟ್ಟು ತಿಳಿಸಿ.

281
00:15:34,000 --> 00:15:37,000
ನನಗೆ ನಿನ್ನ ಇಲ್ಲ, ಸ್ವಲ್ಪ ಮುಂದೆ ಒಂದು ಪ್ರಯತ್ನಿಸಿ ನೋಡೋಣ.

282
00:15:37,000 --> 00:15:42,000
ಸರಿ, ನಮೂದಿಸಿ, ಇಂದು ನೀವು ಹೇಗೆ ಇವೆ ನಿನ್ನ ನ ಮಾಡೋಣವೇ.

283
00:15:42,000 --> 00:15:54,000
ಇಲ್ಲಿ ಅದೃಷ್ಟ ರೀತಿಯ ಗೆಟ್ಟಿಂಗ್, ಈಗ ಹೇಗೆ ನೀವು ಇವೆ ಹಲೋ ಹೇಳಿ.

284
00:15:54,000 --> 00:15:56,000
ಇದು ಡ್ಯಾಮ್.

285
00:15:56,000 --> 00:16:03,000
ಸರಿ, ಆದ್ದರಿಂದ ನಾವು ಅದೃಷ್ಟ ದೊರೆತಿದೆ. ನಾವು ಈ ಸರಿಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನೋಡೋಣ.

286
00:16:03,000 --> 00:16:06,000
ಇಲ್ಲ, ನನಗೆ ಅವಕಾಶ ನಕಲಿಸಿ ಹಿಂದಿರುಗಬಹುದೆಂದು.

287
00:16:06,000 --> 00:16:09,000
ನ ಮತ್ತೆ ಈ ಪ್ರಯತ್ನಿಸೋಣ.

288
00:16:09,000 --> 00:16:12,000
ಸರಿ, ಬೆಂಬಲಿಸಿದ್ದಾರೆ.

289
00:16:12,000 --> 00:16:20,000
ನಾವು ಇನ್ನೂ ಈ ರೀತಿ ಮಾಡುವಾಗ ಕೇಂದ್ರೀಕರಿಸಲು ಹೇಳಿಕೊಳ್ಳಬಹುದು ಎಷ್ಟು ನೋಡುತ್ತಾರೆ.

290
00:16:20,000 --> 00:16:23,000
ಇದು ಡ್ಯಾಮ್. ಎಂದು, ವಾಸ್ತವವಾಗಿ ಸೂಕ್ತವಾಗಿದ್ದಲ್ಲಿ.

291
00:16:23,000 --> 00:16:26,000
ನಾವು ಹೋಗಿ.

292
00:16:26,000 --> 00:16:30,000
ಬಿಂದು.

293
00:16:30,000 --> 00:16:34,000
>> ಈ, ಇದು ಆದರೂ ಮುಜುಗರಕ್ಕೀಡುಮಾಡುವ ಇದು ಮಹಾನ್ ಗೊಂದಲದ ಮೂಲಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ

294
00:16:34,000 --> 00:16:38,000
ಅವರು ಸ್ವತಃ ಸ್ಪಷ್ಟವಾಗಿ ಗೋಚರಿಸುತ್ತವೆ ಏಕೆಂದರೆ ದೋಷಗಳನ್ನು ಹೊಂದಿರುವ ಕಾರ್ಯಕ್ರಮಗಳು ಬರೆಯುವಾಗ

295
00:16:38,000 --> 00:16:40,000
ಕೇವಲ ಒಮ್ಮೆ ಕೆಲವೊಮ್ಮೆ ಸಮಯದಲ್ಲಿ.

296
00:16:40,000 --> 00:16:43,000
ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಕೋಡ್ ಸಂಪೂರ್ಣವಾಗಿ ಒಡೆದುಹೋದರೆ ಎಂಬ

297
00:16:43,000 --> 00:16:46,000
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ ಒಮ್ಮೆ ಮುರಿದು ಇರಬಹುದು

298
00:16:46,000 --> 00:16:49,000
ಕೆಲವೊಮ್ಮೆ, ಮೂಲಭೂತವಾಗಿ ಏನಾಗುತ್ತದೆ ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಗೊತ್ತುಪಡಿಸುತ್ತದೆ ಏಕೆಂದರೆ

299
00:16:49,000 --> 00:16:52,000
ನೀವು ಸ್ವಲ್ಪ ಹೆಚ್ಚಿನ ಮೆಮೊರಿ ವಾಸ್ತವವಾಗಿ, ಯಾವುದೇ ಕಾರಣದಿಂದಾಗಿ ಅಗತ್ಯವಿದೆ

300
00:16:52,000 --> 00:16:57,000
ಆದ್ದರಿಂದ ಬೇರೆಯವರು, ಬಲ 16 ಅಕ್ಷರಗಳನ್ನು ನಿಮ್ಮ ಚಂಕ್ ನಂತರ ಮೆಮೊರಿಯನ್ನು ಬಳಸುತ್ತಿದೆ

301
00:16:57,000 --> 00:17:01,000
ನೀವು 17, 18, 19, ಇರಲಿ, ಅದು ಒಂದು ದೊಡ್ಡ ಒಪ್ಪಂದದ ಅಲ್ಲ ಹೋಗಿ ಹಾಗಾಗಿ.

302
00:17:01,000 --> 00:17:04,000
ಈಗ ಕಂಪ್ಯೂಟರ್, ಇದು ಆ ಸಮಯದಲ್ಲಿ ಕುಸಿತಕ್ಕೆ ಇಲ್ಲ ಕೂಡ,

303
00:17:04,000 --> 00:17:09,000
ಅಂತಿಮವಾಗಿ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಬೈಟ್ ಸಂಖ್ಯೆ 17 ಅಥವಾ 18 ಅಥವಾ 19 ಬಳಸಬಹುದು,

304
00:17:09,000 --> 00:17:14,000
ಇದು, ಹೆಚ್ಚು ಉದ್ದ ಆದರೂ, ನೀವು ಪುಟ್ ನಿಮ್ಮ ಡೇಟಾ ಬಿಂದುವಿನ

305
00:17:14,000 --> 00:17:18,000
ಕೆಲವು ಇತರ ಕಾರ್ಯದ ಮೂಲಕ ಸಮರ್ಥವಾಗಿ ಬರೆಯಲ್ಪಟ್ಟಿತೆಂದರೆ ಕಾಣುವುದು ಇದೆ.

306
00:17:18,000 --> 00:17:21,000
ಅದು ಹಾಗೆಯೇ ಉಳಿಯಲಿದೆ ದೊರೆಯದಿದ್ದಲ್ಲಿ

307
00:17:21,000 --> 00:17:23,000
ಆದರೆ ಅದು ಒಂದು seg ತಪ್ಪು ಉಂಟುಮಾಡುವುದಿಲ್ಲ.

308
00:17:23,000 --> 00:17:26,000
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಅಂತಿಮವಾಗಿ ಸಾಕಷ್ಟು ಪಾತ್ರಗಳು ಒದಗಿಸಿದ

309
00:17:26,000 --> 00:17:29,000
ನಾನು ಮೂಲಭೂತವಾಗಿ, ಮೆಮೊರಿ ನನ್ನ ವಿಭಾಗದಲ್ಲಿ ಮೀರಿದೆ, ಮತ್ತು ಬಾಮ್ ಎಂದು

310
00:17:29,000 --> 00:17:33,000
ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂ "ಕ್ಷಮಿಸಿ, ಯಾವುದೇ ಉತ್ತಮ, ವಿಭಜನೆ ತಪ್ಪು." ಹೇಳಿದರು

311
00:17:33,000 --> 00:17:38,000
>> ಮತ್ತು ನನ್ನ ಇಲ್ಲಿ ಉಳಿದಿದೆ ವೇಳೆ ಈಗ ನೋಡೋಣ ಕೋಶವನ್ನು-

312
00:17:38,000 --> 00:17:40,000
ನಾನು ಇಲ್ಲಿ ಕೋರ್ ಈ ಫೈಲ್ ಎಂದು ಗಮನಿಸಿ.

313
00:17:40,000 --> 00:17:42,000
ಈ ಮತ್ತೆ ಒಂದು ಕೋರ್ ಡಂಪ್ ಎಂದು ಗಮನಿಸಿ.

314
00:17:42,000 --> 00:17:46,000
ಇದು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂನ ಸ್ಮರಣೆಯ ವಿಷಯವನ್ನು ಒಳಗೊಂಡಿರುವ ಒಂದು ಕಡತದ

315
00:17:46,000 --> 00:17:48,000
ಇದು ಘರ್ಷಣೆ ಯಾವ ಹಂತದಲ್ಲಿ,

316
00:17:48,000 --> 00:17:51,000
ಮತ್ತು ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಉದಾಹರಣೆಗೆ ಪ್ರಯತ್ನಿಸಿ ನನ್ನನ್ನು ಇಲ್ಲಿ ಹೋಗಿ ಅವಕಾಶ

317
00:17:51,000 --> 00:17:57,000
ಮತ್ತು, ಕೋರ್ ಎಂಬ ಮೂರನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಸೂಚಿಸಿ ನಂತರ scanf3 ಮೇಲೆ GDB ರನ್ ಮತ್ತು

318
00:17:57,000 --> 00:18:01,000
ಮತ್ತು ಇಲ್ಲಿ ಗಮನಿಸಿ ನಾನು ಕೋಡ್ ಪಟ್ಟಿ ವೇಳೆ,

319
00:18:01,000 --> 00:18:06,000
ನಾವು, ಈ ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ವಾಕಿಂಗ್ ಆರಂಭಿಸಲು GDB ಜೊತೆ ಎಂದಿನಂತೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ

320
00:18:06,000 --> 00:18:10,000
ಮತ್ತು ನಾನು ಎಂದು ಹಿಟ್ ಆಗಿ ಹಂತದ ಆಜ್ಞೆಯನ್ನು ತಕ್ಷಣ ಚಾಲನೆ ಮಾಡಬಹುದು GDB-

321
00:18:10,000 --> 00:18:13,000
ನಾನು ಒಂದು ದೊಡ್ಡ ಸ್ಟ್ರಿಂಗ್ ನಮೂದಿಸುವುದನ್ನು ನಂತರ ಸಂಭಾವ್ಯ ದೋಷಯುಕ್ತ ಸಾಲು ಹಿಟ್, ಬೇಗ

322
00:18:13,000 --> 00:18:16,000
ನಾನು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲಿ ಗುರುತಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

323
00:18:16,000 --> 00:18:19,000
ಹೆಚ್ಚಿನ ಈ ಮೇಲೆ, ಆದರೂ, ಕೋರ್ ಡಂಪ್ ಪರಿಭಾಷೆಯಲ್ಲಿ ವಿಭಾಗದಲ್ಲಿ

324
00:18:19,000 --> 00:18:22,000
ಮತ್ತು ನೀವು ನಿಜವಾಗಿಯೂ ಕೋರ್ ಡಂಪ್ ನ ಒಳಭಾಗದ ಸುತ್ತಲೂ ಇರಿ ಇದರಿಂದ ಇಷ್ಟ

325
00:18:22,000 --> 00:18:27,000
ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ವಿಫಲವಾಗಿದೆ ಯಾವ ಸಾಲಿನಲ್ಲಿ ನೋಡಿ.

326
00:18:27,000 --> 00:18:32,000
ಪಾಯಿಂಟರ್ಸ್ ಮತ್ತು ವಿಳಾಸಗಳನ್ನು ನಂತರ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

327
00:18:32,000 --> 00:18:36,000
ಮೇಲೆ ಇಂದು ಏಕೆಂದರೆ, ನಾವು ಈ ವಸ್ತುಗಳನ್ನು ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಲಘುವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಆರಂಭಿಸಲು ನೀನು

328
00:18:36,000 --> 00:18:40,000
ಮತ್ತು ನಾವು ಅವು ನಿಖರವಾಗಿ ತಿಳಿಯಲು.

329
00:18:40,000 --> 00:18:42,000
ಹೌದು.

330
00:18:42,000 --> 00:18:46,000
>> [ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಮುಂದಿನ ಒಂದು ವನ್ನಾಗಲಿ ಹಾಕಬೇಕು ಇಲ್ಲ ಬರುವ ಭಾಗಶಃ

331
00:18:46,000 --> 00:18:48,000
ಪ್ರಶ್ನೆ ಉತ್ತಮ.

332
00:18:48,000 --> 00:18:51,000
ಹೇಗೆ ನಾನು ಹಿಂದೆ ಮಾಡಿದಂತೆ ಅಕ್ಷರ ಶ್ರೇಣಿಯನ್ನು ಮುಂದಿನ ಒಂದು ವನ್ನಾಗಲಿ ಹಾಕಬೇಕು ಇಲ್ಲ ಬನ್ನಿ

333
00:18:51,000 --> 00:18:53,000
ನಮ್ಮ ಉದಾಹರಣೆಗಳು ಹೆಚ್ಚಿನ?

334
00:18:53,000 --> 00:18:55,000
ಸಣ್ಣ ಉತ್ತರವನ್ನು ಸಾಲುಗಳು ಸ್ವಲ್ಪ ವಿಶೇಷವಾಗಿದೆ ಹೊಂದಿದೆ.

335
00:18:55,000 --> 00:18:59,000
ನೀವು ಬಹುತೇಕ, ವಾಸ್ತವವಾಗಿ ಒಂದು ವಿಳಾಸಕ್ಕೆ ಎಂದು ಒಂದು ಬಫರ್ ನಗರದ

336
00:18:59,000 --> 00:19:03,000
ಮತ್ತು ಇದು ಆದ್ದರಿಂದ ಕೇಸ್ ಎಂದು ನಡೆಯುವ ಚದರ ಬ್ರಾಕೆಟ್ ಸಂಕೇತನ

337
00:19:03,000 --> 00:19:06,000
ನಾವು ಕಾಣುವ 0, ಬ್ರಾಕೆಟ್ 1, ಹೋಗಿ ಆ ಮೂಲಕ ಒಂದು ಅನುಕೂಲ ಹೊಂದಿದೆ

338
00:19:06,000 --> 00:19:10,000
* ಸಂಕೇತನ ಬಳಸದೆಯೇ ಬ್ರಾಕೆಟ್ 2.

339
00:19:10,000 --> 00:19:13,000
ಒಂದು ಬಿಳಿ ಸುಳ್ಳು ಒಂದು ಬಿಟ್ ಏಕೆಂದರೆ ರಚನೆಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್

340
00:19:13,000 --> 00:19:17,000
ವಾಸ್ತವವಾಗಿ, ಒಂದು ಸ್ವಲ್ಪ ಭಿನ್ನವಾಗಿರುತ್ತವೆ, ಆದರೆ ಅವುಗಳನ್ನು ಆದರೆ ಯಾವಾಗಲೂ ಪರ್ಯಾಯವಾಗಿ ಬಳಸಬಹುದು.

341
00:19:17,000 --> 00:19:21,000
ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳಬೇಕೆಂದರೆ, ಒಂದು ಕಾರ್ಯ ಮೆಮೊರಿಯ ಒಂದು ಪಾಲನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ನಿರೀಕ್ಷಿಸುತ್ತಿರುವುದಾಗಿ ಮಾಡಿದಾಗ,

342
00:19:21,000 --> 00:19:24,000
ನೀವು ಎರಡೂ, ಇದು malloc ನೀಡಿದ ಎಂದು ಒಂದು ವಿಳಾಸಕ್ಕೆ ರವಾನಿಸಬಹುದು

343
00:19:24,000 --> 00:19:29,000
ಮತ್ತು ನಾವು ಬಹಳ ಹಿಂದೆ ಮತ್ತೆ malloc ನೋಡುತ್ತಾರೆ, ಅಥವಾ ನೀವು ಒಂದು ರಚನೆಯ ಹೆಸರು ರವಾನಿಸಬಹುದು.

344
00:19:29,000 --> 00:19:32,000
ಅವರು ಈಗಾಗಲೇ ನೀವು ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ವನ್ನಾಗಲಿ ಮಾಡಲು ಹೊಂದಿಲ್ಲ

345
00:19:32,000 --> 00:19:34,000
ಮೂಲಭೂತವಾಗಿ ವಿಳಾಸಗಳನ್ನು ಇಷ್ಟ.

346
00:19:34,000 --> 00:19:36,000
ಅಪವಾದವಾಗಿದೆ ಆ.

347
00:19:36,000 --> 00:19:39,000
ಚದರ ಆವರಣಗಳಲ್ಲಿ ಅವುಗಳ ವಿಶೇಷ ಮಾಡಲು.

348
00:19:39,000 --> 00:19:41,000
>> ನೀವು ಬಫರ್ ಮುಂದಿನ ಒಂದು ವನ್ನಾಗಲಿ ಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ?

349
00:19:41,000 --> 00:19:43,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ.

350
00:19:43,000 --> 00:19:46,000
ಈ ಮೂಲೆಯಲ್ಲಿ ಪ್ರಕರಣದ, ಏಕೆಂದರೆ, ಮತ್ತೆ ಕೆಲಸ ಮಾಡುವುದಿಲ್ಲ

351
00:19:46,000 --> 00:19:49,000
ಅಲ್ಲಿ ಸರಣಿಗಳ ತುಂಬಾ ವಾಸ್ತವವಾಗಿ ವಿಳಾಸಗಳು ಅವು.

352
00:19:49,000 --> 00:19:54,000
ಆದರೆ ಬಹುಶಃ ಇತರ ಉದಾಹರಣೆಗಳು ಆ ಮುಂಚೆಯೇ ಹಿಂತಿರುಗಬೇಕಾಗಿದೆ ಮಾಡುತ್ತೇವೆ.

353
00:19:54,000 --> 00:19:56,000
ನ ಇಲ್ಲಿ ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.

354
00:19:56,000 --> 00:20:00,000
ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂದು ಕೆಲವು ಬಾರಿಗೆ ಬಳಸಿಕೊಂಡು ನಾವು ಒಂದು ಅಕ್ಷಾಂಶ ರಚನೆಯನ್ನು ಹೊಂದಿವೆ.

355
00:20:00,000 --> 00:20:02,000
ಬಿಂದುವಿನಲ್ಲಿ ಕೇಸ್, ನಾವು ಕೇವಲ ಹೊಂದಿತ್ತು ಎಂಬುದನ್ನು.

356
00:20:02,000 --> 00:20:04,000
ಆದರೆ ಸರಣಿಗಳ ಕೆಲವು ಸಾಟಿಯಾಗಿ ಮತ್ತು ಪರಿಣಾಮಗಳನ್ನು ಹೊಂದಿವೆ.

357
00:20:04,000 --> 00:20:06,000
ಅರೆಸ್ ಸಂತೋಷವನ್ನು ಏಕೆ?

358
00:20:06,000 --> 00:20:11,000
ನೀವು-ಗೆ ಒಂದು ವಿಷಯ ನೀವು ಸರಣಿಗಳ ಸರಣಿಗಳ-ಬಗ್ಗೆ ಇಷ್ಟ ವ್ಯಾಪ್ತಿ ಏನು?

359
00:20:11,000 --> 00:20:13,000
ಯಾವ ಬಗ್ಗೆ ಅನುಕೂಲಕರ ಈಸ್? ಬಲವಾದ ಯಾವುದು?

360
00:20:13,000 --> 00:20:18,000
ಏಕೆ ನಾವು ಮೊದಲ ಸ್ಥಳದಲ್ಲಿ ಅವರನ್ನು ಪರಿಚಯಿಸಲು ನೀಡಲಿಲ್ಲ?

361
00:20:18,000 --> 00:20:20,000
ಹೌದು.

362
00:20:20,000 --> 00:20:27,000
[ವಿದ್ಯಾರ್ಥಿ] ಅವರು ಅಕ್ಷಾಂಶ ಸಾಕಷ್ಟು ಸಂಗ್ರಹಿಸಬಹುದು, ಮತ್ತು ನೀವು ಸಂಪೂರ್ಣ ವಿಷಯವನ್ನು ಬಳಸಲು ಹೊಂದಿಲ್ಲ.

363
00:20:27,000 --> 00:20:29,000
ನೀವು ವಿಭಾಗ ಬಳಸಬಹುದು.

364
00:20:29,000 --> 00:20:32,000
ಉತ್ತಮ, ನೀವು ಡೇಟಾವನ್ನು ಸಾಕಷ್ಟು ಸಂಗ್ರಹಿಸಬಹುದು ಸಹಿತ,

365
00:20:32,000 --> 00:20:35,000
ಮತ್ತು, ನೀವು ಅಗತ್ಯವಾಗಿ ಅದನ್ನು ಬಳಸಲು ಇಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು overallocate ಮಾಡಬಹುದು

366
00:20:35,000 --> 00:20:39,000
ಹೇಗೆ ನಿರೀಕ್ಷಿಸಬಹುದು ಏನೋ ಅನೇಕ ನೀವು ಮುಂಚಿತವಾಗಿ ಗೊತ್ತಿಲ್ಲ ವೇಳೆ ಅನುಕೂಲಕರ ಇರಬಹುದು ಇದು.

367
00:20:39,000 --> 00:20:41,000
>> GetString ಪರಿಪೂರ್ಣ ಉದಾಹರಣೆ.

368
00:20:41,000 --> 00:20:44,000
ನಮಗೆ ಬರೆದ GetString, ನಿರೀಕ್ಷಿಸಬಹುದು ಎಷ್ಟು ಅಕ್ಷರಗಳನ್ನು ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿದೆ

369
00:20:44,000 --> 00:20:48,000
ಆದ್ದರಿಂದ ನಾವು ಹೊಂದಿಕೊಂಡಿರುವ ಮೆಮೊರಿಯ ಭಾಗಗಳಲ್ಲಿ ನಿಯೋಜಿಸಿ ಎಂದು ವಾಸ್ತವವಾಗಿ ಒಳ್ಳೆಯದು.

370
00:20:48,000 --> 00:20:51,000
ಅರೆಸ್ ನಾವು ಈಗ ಒಂದೆರಡು ವಾರಗಳ ಹಿಂದೆ ಕಂಡ ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು

371
00:20:51,000 --> 00:20:54,000
ನಿಮ್ಮ ಕೋಡ್ ಅತ್ಯಂತ ಕಳಪೆಯಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಯಿತು ಏನೋ ಆವರಿಸಲಿದೆ ಆರಂಭಿಸುತ್ತದೆ ಅಲ್ಲಿ.

372
00:20:54,000 --> 00:20:57,000
ನಾನು ಡೇವಿಡ್ ಎಂಬ ವಿದ್ಯಾರ್ಥಿ ರಚನೆಯಾಗಿದ್ದು ಸ್ಮರಿಸುತ್ತಾರೆ

373
00:20:57,000 --> 00:21:00,000
ಮತ್ತು ನಂತರ, ಆದಾಗ್ಯೂ, ವಾಸ್ತವವಾಗಿ ಪರ್ಯಾಯ ಆಗಿತ್ತು

374
00:21:00,000 --> 00:21:04,000
ಒಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಎಂಬ ಹೆಸರು ಮತ್ತು ನನ್ನ, ಮನೆ ಎಂಬ ಇನ್ನೊಂದು ವೇರಿಯಬಲ್ ಹೊಂದಿದ್ದು,

375
00:21:04,000 --> 00:21:08,000
ಆ ಕಥೆಯಲ್ಲಿ ನಾನು ಯಾವುದೋ ಪರಿಚಯಿಸಲು ಬಯಸಿದರು ಏಕೆಂದರೆ ID ಎಂಬ ಮತ್ತೊಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ

376
00:21:08,000 --> 00:21:11,000
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ರಾಬ್ ಇಷ್ಟ, ಆದ್ದರಿಂದ ನಾನು ಒಂದು ನಿಮಿಷ ನಿರೀಕ್ಷಿಸಿ ನಿರ್ಧರಿಸಿದರು

377
00:21:11,000 --> 00:21:13,000
ನಾನು ಈ ಅಸ್ಥಿರಗಳು ಮರುಹೆಸರಿಸಲು ಅಗತ್ಯವಿದೆ.

378
00:21:13,000 --> 00:21:16,000
ಲೆಟ್ಸ್ ಗಣಿ NAME1, ID1, house1 ಕರೆ.

379
00:21:16,000 --> 00:21:20,000
ಲೆಟ್ಸ್ ರಾಬ್ ನ NAME2, house2, ID2 ಕರೆ.

380
00:21:20,000 --> 00:21:22,000
ಆದರೆ ನಂತರ ಯಾವ ಟಾಮಿ ಬಗ್ಗೆ ಒಂದು ನಿಮಿಷ, ನಿರೀಕ್ಷಿಸಿ?

381
00:21:22,000 --> 00:21:24,000
ನಾವು ಮೂರು ಅಸ್ಥಿರ ಹೊಂದಿತ್ತು.

382
00:21:24,000 --> 00:21:27,000
ಬೇರೆಯವರ, ಅಸ್ಥಿರ ನಾಲ್ಕು ಸೆಟ್ ಪರಿಚಯಿಸಿತು.

383
00:21:27,000 --> 00:21:30,000
ವಿಶ್ವದ, ಬೇಗನೆ ಗೊಂದಲಮಯ ಪಡೆಯಲು ಪ್ರಾರಂಭಿಸಿದರು

384
00:21:30,000 --> 00:21:33,000
ಆದ್ದರಿಂದ ನಾವು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಪರಿಚಯಿಸಿತು, ಮತ್ತು ಒಂದು struct ಬಗ್ಗೆ ಬಲವಾದ ನ?

385
00:21:33,000 --> 00:21:39,000
ಒಂದು ಸಿ struct ನೀವು ಏನು ಅವಕಾಶ ಇಲ್ಲ?

386
00:21:39,000 --> 00:21:42,000
ಇಂದು ನಿಜವಾಗಿಯೂ ವಿಚಿತ್ರವಾಗಿ ಇಲ್ಲಿದೆ.

387
00:21:42,000 --> 00:21:44,000
ಏನು? >> [ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

388
00:21:44,000 --> 00:21:47,000
ಹೌದು, ನಿರ್ದಿಷ್ಟವಾಗಿ, typedef ನೀವು ಹೊಸ ಅಕ್ಷಾಂಶ ರೀತಿಯ ರಚಿಸಲು ಅನುಮತಿಸುತ್ತದೆ

389
00:21:47,000 --> 00:21:51,000
ಮತ್ತು struct, struct ಕೀವರ್ಡ್, ನೀವು ಕೋಶೀಕರಿಸುತ್ತದೆ ಅನುಮತಿಸುತ್ತದೆ

390
00:21:51,000 --> 00:21:54,000
ಒಟ್ಟಿಗೆ ಮಾಹಿತಿ ಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಸಂಬಂಧಿಸಿದ ತುಣುಕುಗಳು

391
00:21:54,000 --> 00:21:56,000
ನಂತರ ಅವುಗಳನ್ನು ಒಂದು ವಿದ್ಯಾರ್ಥಿ ರೀತಿಯ ಕರೆ.

392
00:21:56,000 --> 00:21:58,000
>> ಈಗ ನಾವು ಮಾದರಿಯನ್ನು ಏಕೆಂದರೆ ಒಳ್ಳೆಯ ಆಗಿತ್ತು

393
00:21:58,000 --> 00:22:03,000
ಒಂದು ವೇರಿಯಬಲ್ ವಿದ್ಯಾರ್ಥಿ ನ ಹೆಚ್ಚು ರೀತಿಯ ಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಸ್ಥಿರ ಕಲ್ಪನೆ

394
00:22:03,000 --> 00:22:07,000
ಬದಲಿಗೆ ನಿರಂಕುಶವಾಗಿ ಇತ್ಯಾದಿ ಒಂದು ತಂತಿಗೆ ಒಂದು, ಒಂದು ID ಯನ್ನು ಒಂದು ಹೊಂದಿರುವ, ಮತ್ತು.

395
00:22:07,000 --> 00:22:10,000
ಅವರು ನಮ್ಮ ಕೋಡ್ ಸ್ವಚ್ಛಗೊಳಿಸುವ ಆರಂಭಿಸಲು ಅವಕಾಶ ಏಕೆಂದರೆ ಅರೆಸ್ ಸಂತೋಷವನ್ನು ಇವೆ.

396
00:22:10,000 --> 00:22:13,000
ಆದರೆ ಯಾವ ವ್ಯೂಹದ ಈಗ ತೊಂದರೆಯೂ ಆಗಿದೆ?

397
00:22:13,000 --> 00:22:15,000
ನೀವು ಏನು ಸಾಧ್ಯವಿಲ್ಲ? ಹೌದು.

398
00:22:15,000 --> 00:22:17,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಅದನ್ನು ಎಷ್ಟು ದೊಡ್ಡ ಗೊತ್ತಿರಬೇಕಾಗುತ್ತದೆ.

399
00:22:17,000 --> 00:22:19,000
ನೀವು ಎಷ್ಟು ದೊಡ್ಡ ತಿಳಿಯಲು ಹೊಂದಿವೆ, ಇದು ಒಂದು ನೋವಿನ ರೀತಿಯ ಹಾಗೆ.

400
00:22:19,000 --> 00:22:21,000
ನೀವು ಆ ಮೊದಲು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನುಭವ ಎಂದು ತಿಳಿದಿರುವ ಭಾಷೆಗಳಲ್ಲಿ ಅನೇಕ,

401
00:22:21,000 --> 00:22:24,000
ಜಾವಾ ನಂತಹ, ನೀವು ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್, ನಿರ್ದಿಷ್ಟವಾಗಿ ಒಂದು ರಚನೆಯ ಕೇಳಬಹುದು

402
00:22:24,000 --> 00:22:28,000
ಹೇಗೆ ದೊಡ್ಡ ನೀವು ಮಾತನಾಡಲು ಒಂದು ಉದ್ದದ, ಆಸ್ತಿ, ಜೊತೆಗೆ, ಮತ್ತು ನಿಜಕ್ಕೂ ಅನುಕೂಲಕರ ಇಲ್ಲಿದೆ.

403
00:22:28,000 --> 00:22:32,000
ಸಿ, ನೀವು ಸಹ ಒಂದು ಜೆನೆರಿಕ್ ರಚನೆಯ ಮೇಲೆ strlen ಕರೆ ಸಾಧ್ಯವಿಲ್ಲ

404
00:22:32,000 --> 00:22:35,000
ಪದ ಸೂಚಿಸುತ್ತದೆ ಎಂದು strlen ಏಕೆಂದರೆ, ಕೇವಲ ತಂತಿಗಳನ್ನು ಮಾತ್ರ

405
00:22:35,000 --> 00:22:39,000
ಮತ್ತು ನೀವು ಈ ಮಾನವ ಪದ್ಧತಿಯಲ್ಲಿನ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು

406
00:22:39,000 --> 00:22:43,000
ಒಂದು \ 0, ಆದರೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿರುವ, ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿ, ಕೇವಲ ಮೆಮೊರಿಯ ಒಂದು ಪಾಲನ್ನು ಹೊಂದಿದೆ.

407
00:22:43,000 --> 00:22:46,000
ಇದು ints ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಆಗಿದ್ದರೆ, ಕೆಲವು ವಿಶೇಷ ಪಾತ್ರ ಇರುವಂತೆ ಹೋಗುತ್ತಿಲ್ಲ ವಿಶೇಷವೇನು

408
00:22:46,000 --> 00:22:48,000
ಕೊನೆಯಲ್ಲಿ ನೀವು ಕಾಯುತ್ತಿದೆ.

409
00:22:48,000 --> 00:22:50,000
ನೀವು ರಚನೆಯ ಉದ್ದ ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

410
00:22:50,000 --> 00:22:54,000
ಒಂದು ರಚನೆಯ ಮತ್ತೊಂದು ಹಿನ್ನಡೆಯೆಂದರೆ ಸ್ವತಃ GetString ಮುಖ್ಯ ಸಾಕಿದರು.

411
00:22:54,000 --> 00:22:59,000
ಒಂದು ರಚನೆಯ ಮತ್ತೊಂದು ಹಿನ್ನಡೆಯೆಂದರೆ ಯಾವುದು?

412
00:22:59,000 --> 00:23:01,000
ಸರ್, ನೀವು ನನ್ನನ್ನು ಇಂದು.

413
00:23:01,000 --> 00:23:04,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ] >> ಇದು ಎಂಬುದರ?

414
00:23:04,000 --> 00:23:06,000
ಇದು ಸ್ಟಾಕ್ ರಂದು ಘೋಷಣೆ ಮಾಡಿದ.

415
00:23:06,000 --> 00:23:09,000
ಸರಿ, ಸ್ಟಾಕ್ ಘೋಷಿಸಿದರು. ಏಕೆ ನೀವು ಇಷ್ಟಪಡುವುದಿಲ್ಲ?

416
00:23:09,000 --> 00:23:13,000
[ವಿದ್ಯಾರ್ಥಿ] ಮರುಬಳಕೆಯಾಗುತ್ತವೆ ಯಾಕೆಂದರೆ.

417
00:23:13,000 --> 00:23:15,000
ಇದು ಮರುಬಳಕೆ ಮಾಡಲ್ಪಡುತ್ತವೆ.

418
00:23:15,000 --> 00:23:18,000
ಸರಿ, ನೀವು ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಳಸುತ್ತವೆ ವೇಳೆ,

419
00:23:18,000 --> 00:23:21,000
ಇದು ಸ್ಟಾಕ್ ಮೇಲೆ ಏಕೆಂದರೆ ನೀವು, ಉದಾಹರಣೆಗೆ, ಅದನ್ನು ಹಿಂದಿರುಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

420
00:23:21,000 --> 00:23:23,000
ಸರಿ, ಒಂದು ಅನನುಕೂಲವೆಂದರೆ ಇಲ್ಲಿದೆ.

421
00:23:23,000 --> 00:23:25,000
ಮತ್ತು ಹೇಗೆ ಸಹಿತ ಇತರ ಒಂದು?

422
00:23:25,000 --> 00:23:28,000
ನೀವು ನಿಯೋಜಿಸಿ ಒಮ್ಮೆ ನೀವು ಹೆಚ್ಚು ಜಾಗವನ್ನು ಅಗತ್ಯವಿದ್ದರೆ ರೀತಿಯ ಸ್ಕ್ರೆವೆದ್ ಆರ್

423
00:23:28,000 --> 00:23:30,000
ಆ ವಿನ್ಯಾಸಗಳ ಹೆಚ್ಚು.

424
00:23:30,000 --> 00:23:34,000
>> ನಾವು, ನಮಗೆ ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡಿತು ಮರುಸ್ಥಾಪನೆ, malloc ಪರಿಚಯಿಸಿತು.

425
00:23:34,000 --> 00:23:37,000
ಆದರೆ ಸಂಪೂರ್ಣವಾಗಿ ಬೇರೆ ಪ್ರಪಂಚದ ಯಾವ ಪ್ರಯತ್ನಿಸಿದ ವೇಳೆ?

426
00:23:37,000 --> 00:23:40,000
ನಾವು ಆ ಸಮಸ್ಯೆಗಳು ಒಂದೆರಡು ಪರಿಹರಿಸಲು ಬಯಸಿತು ಹೀಗಾದರೆ

427
00:23:40,000 --> 00:23:45,000
ಆದ್ದರಿಂದ ನಾವು ಬದಲಿಗೆ-ನನ್ನ ಪೆನ್ ಇಲ್ಲಿಗೆ ನಿದ್ದೆ ಬಿದ್ದಿದೆ

428
00:23:45,000 --> 00:23:51,000
ನಾವು ಬದಲಿಗೆ ಮೂಲಭೂತವಾಗಿ ಹೀಗೆ ಇಲ್ಲದ ವಿಶ್ವ ರಚಿಸಲು ಬಯಸಿದರೆ?

429
00:23:51,000 --> 00:23:56,000
ಈ ಒಂದು ಸರಣಿ, ಮತ್ತು, ವಾಸ್ತವವಾಗಿ, ಈ ರೀತಿಯ, ಒಮ್ಮೆ ನಾವು ರಚನೆಯ ಕೊನೆಯ ಹಿಟ್ ಹದಗೆಡುತ್ತಾ

430
00:23:56,000 --> 00:24:00,000
ಮತ್ತು ನಾನು ಈಗ ಇನ್ನು ಮುಂದೆ ಮತ್ತೊಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಮತ್ತೊಂದು ಪಾತ್ರಕ್ಕೆ ಸ್ಥಳವನ್ನು.

431
00:24:00,000 --> 00:24:03,000
ನಾವು ರೀತಿಯ ಪೂರ್ವಭಾವಿಯಾಗಿಯೇ ಚೆನ್ನಾಗಿ ಹೇಳಲು ವೇಳೆ, ಏಕೆ ನಾವು ವಿಶ್ರಾಂತಿ ಇಲ್ಲ ಏನು

432
00:24:03,000 --> 00:24:07,000
ಮೆಮೊರಿ ಎಲ್ಲಾ ಭಾಗಗಳಲ್ಲಿ, ಒಂದರ ಹಿಂದೆ ಒಂದರಂತೆ ಸಮೀಪದ ಎಂದು ಈ ಅವಶ್ಯಕತೆಯನ್ನು

433
00:24:07,000 --> 00:24:10,000
ಮತ್ತು ಏಕೆ ಒಂದು ಇಂಟ್ ಅಥವಾ ಚಾರ್ ಅಗತ್ಯವಿರುವಾಗ, ಮಾಡುವುದಿಲ್ಲ,

434
00:24:10,000 --> 00:24:12,000
ಅವುಗಳನ್ನು ಒಂದು ನನಗೆ ಜಾಗವನ್ನು ನೀಡಿ?

435
00:24:12,000 --> 00:24:14,000
ಮತ್ತು ನಾನು ಮತ್ತೊಂದು ಅಗತ್ಯವಿರುವಾಗ, ನನಗೆ ಮತ್ತೊಂದು ಜಾಗವನ್ನು ನೀಡಿ

436
00:24:14,000 --> 00:24:16,000
ಮತ್ತು ನಾನು ಮತ್ತೊಂದು ಅಗತ್ಯವಿರುವಾಗ, ನನಗೆ ಮತ್ತೊಂದು ಜಾಗವನ್ನು ನೀಡಿ.

437
00:24:16,000 --> 00:24:19,000
ಇದು ಪ್ರಯೋಜನವನ್ನು ಈಗ ಆ ವೇಳೆ ಬೇರೊಬ್ಬರ ಆಗಿದೆ

438
00:24:19,000 --> 00:24:21,000
ಇಲ್ಲಿ ಸುಮಾರು ಮೆಮೊರಿ, ಯಾವುದೇ ದೊಡ್ಡ ಒಪ್ಪಂದ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

439
00:24:21,000 --> 00:24:25,000
ನಾನು ಇಲ್ಲಿ ಮತ್ತು ಈ ಒಂದು ಮೆಮೊರಿ ಈ ಹೆಚ್ಚುವರಿ ಪಡೆ ಕರೆದೊಯ್ಯಲಿದ್ದೇವೆ.

440
00:24:25,000 --> 00:24:28,000
>> ಈಗ, ಇಲ್ಲಿ ಮಾತ್ರ ಕ್ಯಾಚ್ ನಾನು ಹೊಂದಿವೆ ರೀತಿ ಸುಮಾರು ಭಾವಿಸುವ ಆಗಿದೆ

441
00:24:28,000 --> 00:24:30,000
ವಿಭಿನ್ನ ಅಸ್ಥಿರ ಇಡೀ ಗುಂಪೇ.

442
00:24:30,000 --> 00:24:33,000
ಈ ಸಂಭಾವ್ಯ ಐದು ವಿಭಿನ್ನ ಅಸ್ಥಿರ ಭಾಸವಾಗುತ್ತಿದೆ.

443
00:24:33,000 --> 00:24:36,000
ಆದರೆ ತಂತಿಗಳನ್ನು ಒಂದು ಕಲ್ಪನೆ ಏನು ಕದಿಯಲು ವೇಳೆ

444
00:24:36,000 --> 00:24:41,000
ನಾನು ಈ ಮಾಡಿದರೆ ಆ ಮೂಲಕ ನಾವು ಹೇಗಾದರೂ ಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಒಟ್ಟಾಗಿ ಈ ವಿಷಯಗಳನ್ನು ಲಿಂಕ್, ಮತ್ತು ಏನು?

445
00:24:41,000 --> 00:24:44,000
ಈ ನನ್ನ ಅತ್ಯಂತ ಕಳಪೆ ಡ್ರಾ ಬಾಣದ ಹೊಂದಿದೆ.

446
00:24:44,000 --> 00:24:46,000
ಆದರೆ ಇಟ್ಟುಕೋ ಎಂದು ಮೆಮೊರಿ ಈ ಭಾಗಗಳಲ್ಲಿ ಪ್ರತಿ

447
00:24:46,000 --> 00:24:52,000
ಇತರ ತೋರಿಸಿದರು, ಮತ್ತು ಈ ವ್ಯಕ್ತಿ, ತನ್ನ ಹಕ್ಕನ್ನು ಯಾವುದೇ ಒಡಹುಟ್ಟಿದವರು ಹೊಂದಿದೆ,

448
00:24:52,000 --> 00:24:54,000
ಉದಾಹರಣೆಗೆ ಬಾಣದ ಇಲ್ಲ.

449
00:24:54,000 --> 00:24:56,000
ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಎಂದು ಏನನ್ನು ಹೌದು.

450
00:24:56,000 --> 00:25:00,000
ಇದು ನಮಗೆ ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್ ನಿಯೋಜಿಸಿ ಅನುಮತಿಸುವ ಹೊಸ ಅಕ್ಷಾಂಶ ರಚನೆಯಾಗಿದೆ

451
00:25:00,000 --> 00:25:03,000
ನಂತರ ಮತ್ತೊಂದು, ಇನ್ನೊಂದು, ಮತ್ತೊಂದು, ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನಾವು ಬಯಸುವ

452
00:25:03,000 --> 00:25:07,000
ಒಂದು ಕಾರ್ಯಕ್ರಮದ ಅವಧಿಯಲ್ಲಿ, ಅವರು ಎಲ್ಲಾ ಹೇಗಾದರೂ ಸಂಬಂಧಿತ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ

453
00:25:07,000 --> 00:25:11,000
ಅಕ್ಷರಶಃ ಸರಣಿ ಮೂಲಕ ಒಟ್ಟಿಗೆ ಅವುಗಳನ್ನು, ಮತ್ತು ನಾವು ಸಚಿತ್ರವಾಗಿ ಇಲ್ಲಿ ಬಾಣ ಎಂದು ಮಾಡಿದರು.

454
00:25:11,000 --> 00:25:15,000
ಆದರೆ ಕೋಡ್ ನಲ್ಲಿ, ಏನು, ನೀವು ಹೇಗಾದರೂ ಸಂಪರ್ಕಿಸಿವ ಮೂಲಕ ಯಾಂತ್ರಿಕ ಎಂದು

455
00:25:15,000 --> 00:25:20,000
ಬಹುತೇಕ ಸ್ಕ್ರ್ಯಾಚ್ ನಂತಹ ಮತ್ತೊಂದು ಚಂಕ್ ಒಂದು ಪಡೆ?

456
00:25:20,000 --> 00:25:22,000
ನಾವು, ಒಂದು ಸೂಚಕವು ಬಲ ಬಳಸಬಹುದು?

457
00:25:22,000 --> 00:25:25,000
ಏಕೆಂದರೆ ಎಡಭಾಗದ ಆಯತದಲ್ಲಿ ರಿಂದ ವಿಶೇಷವೇನು ನಿಜಕ್ಕೂ ಬಾಣ,

458
00:25:25,000 --> 00:25:31,000
ಇದನ್ನು ಇಲ್ಲಿ ಈ ವ್ಯಕ್ತಿ, ಈ ಚೌಕದ ಒಳಗೆ ಹೊಂದಿರುತ್ತವೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

459
00:25:31,000 --> 00:25:34,000
ಕೇವಲ ಕೆಲವು ints, ಕೆಲವು ಚಾರ್ ಅಲ್ಲ, ಆದರೆ ನಾನು ನಿಜವಾಗಿ ನಿಯೋಜಿತವಾದ ಏನು

460
00:25:34,000 --> 00:25:37,000
ಆದ್ದರಿಂದ ಈಗ ಸ್ವಲ್ಪ ಹೆಚ್ಚುವರಿ ಸ್ಥಳವನ್ನು

461
00:25:37,000 --> 00:25:41,000
ಈ ನನಗೆ ಬೆಲೆ ಹೋಗುತ್ತದೆ ಸಹ ಮೆಮೊರಿ ನನ್ನ ಭಾಗಗಳಲ್ಲಿ ಪ್ರತಿ,

462
00:25:41,000 --> 00:25:45,000
ಈಗ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಆಯತಾಕಾರದ ಕಾಣುತ್ತದೆ ಅಲ್ಲಿ ಮೆಮೊರಿ ಭಾಗಗಳಲ್ಲಿ ಒಂದು

463
00:25:45,000 --> 00:25:47,000
ಹಲವಾರು ಬಳಸಲಾಗುತ್ತದೆ, ಸಂಖ್ಯೆ 1 ನಂತಹ

464
00:25:47,000 --> 00:25:50,000
ತದನಂತರ ಈ ವ್ಯಕ್ತಿ, ಸಂಖ್ಯೆ 2 ಸಂಗ್ರಹಿಸುತ್ತದೆ ವೇಳೆ

465
00:25:50,000 --> 00:25:52,000
ಮೆಮೊರಿ ಈ ಇತರ ಚಂಕ್, ಬಾಣ ಬಳಸಲಾಗುತ್ತದೆ

466
00:25:52,000 --> 00:25:54,000
ಅಥವಾ ಹೆಚ್ಚು ವಾಸ್ತವಿಕ, ಒಂದು ಪಾಯಿಂಟರ್.

467
00:25:54,000 --> 00:25:59,000
ಮತ್ತು, ನಾನು ಆ ವ್ಯಕ್ತಿ ಕಡೆ ಬಳಸುತ್ತವೆ ನಾನು ಇಲ್ಲಿ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ 3 ಸಂಗ್ರಹಿಸಲು ಇಟ್ಟುಕೋ

468
00:25:59,000 --> 00:26:02,000
ಈಗ ಈ ವ್ಯಕ್ತಿ, ನ ನಾನು ಮಾತ್ರ ಮೆಮೊರಿ ಮೂರು ಭಾಗಗಳಲ್ಲಿ ಬಯಸುವ ಭಾವಿಸಿರಿ ಅವಕಾಶ.

469
00:26:02,000 --> 00:26:05,000
ನಾನು ಶೂನ್ಯ ಸೂಚಿಸುತ್ತದೆ, ಆ ಮೂಲಕ ಒಂದು ರೇಖೆ ಮಾಡುತ್ತೇವೆ.

470
00:26:05,000 --> 00:26:07,000
ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಅಕ್ಷರ ಇಲ್ಲ.

471
00:26:07,000 --> 00:26:10,000
>> ವಾಸ್ತವವಾಗಿ, ಈ ನಾವು ಅನುಷ್ಠಾನಕ್ಕೆ ಬಗ್ಗೆ ತಿಳಿಯಲು ಹೇಗೆ

472
00:26:10,000 --> 00:26:12,000
ಲಿಂಕ್ ಪಟ್ಟಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ ಎಂದು ಏನಾದರೂ.

473
00:26:12,000 --> 00:26:18,000
ಸಂಬಂಧಿಸಿದ ಪಟ್ಟಿಯ ಹೊಸ ಅಕ್ಷಾಂಶ ರಚನೆಯಾಗಿದೆ, ಮತ್ತು ಇದು ಕಡೆಗೆ ಒಂದು ಮೆಟ್ಟಿಲು ಸ್ಟೋನ್ನ

474
00:26:18,000 --> 00:26:21,000
ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಲು ಪ್ರಾರಂಭವಾಗುವ ಹೆಚ್ಚು ಆಸಕ್ತ ಅಕ್ಷಾಂಶ ರಚನೆಗಳು

475
00:26:21,000 --> 00:26:23,000
ಫೇಸ್ಬುಕ್ ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಸಾಲುಗಳನ್ನು ಮತ್ತು Google ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಉದ್ದಕ್ಕೂ

476
00:26:23,000 --> 00:26:26,000
ನೀವು ದೊಡ್ಡ ಡೇಟಾ ಸೆಟ್ಗಳನ್ನು ಹೊಂದಿವೆ, ಮತ್ತು ಇದು ಕತ್ತರಿಸಿ ಎಂದಿಗೂ ಅಲ್ಲಿ

477
00:26:26,000 --> 00:26:29,000
ನೇರ ಪ್ರತಿಯೊಂದನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ರೇಖೀಯ ಹುಡುಕಾಟ ರೀತಿಯ ಬಳಸಲು

478
00:26:29,000 --> 00:26:31,000
ಬೈನರಿ ಸರ್ಚ್ ನಂತಹ ಅಥವಾ ಏನೋ.

479
00:26:31,000 --> 00:26:33,000
ನೀವು ಉತ್ತಮ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಾರಿ ಬಯಸುವ.

480
00:26:33,000 --> 00:26:37,000
ವಾಸ್ತವವಾಗಿ, ಪವಿತ್ರ Grails ಒಂದು ನಾವು ನಂತರ ಈ ವಾರ ಅಥವಾ ಮುಂದಿನ ಬಗ್ಗೆ ಮಾತನಾಡಲು ವಿಲ್

481
00:26:37,000 --> 00:26:41,000
ಯಾರ ಚಾಲನೆಯ ಸಮಯ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ ಒಂದು ಕ್ರಮಾವಳಿ.

482
00:26:41,000 --> 00:26:44,000
ಇತರ ಪದಗಳಲ್ಲಿ, ಇದು ಯಾವಾಗಲೂ ಅಷ್ಟೇ ಸಮಯವನ್ನು ಯಾವುದೇ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

483
00:26:44,000 --> 00:26:47,000
ಇನ್ಪುಟ್, ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಬಲವಾದ ಹೇಗೆ ದೊಡ್ಡ

484
00:26:47,000 --> 00:26:49,000
ತುಂಬಾ ಲಾಗರಿದಮ್ ಏನಾದರೂ ಹೆಚ್ಚು.

485
00:26:49,000 --> 00:26:51,000
ಇಲ್ಲಿ ಈ ತೆರೆಯಲ್ಲಿ ಎಂದರೇನು?

486
00:26:51,000 --> 00:26:55,000
ಆಯತಗಳನ್ನು ಪ್ರತಿಯೊಂದು ನಾನು ಕೈಯಿಂದ ಸೆಳೆಯಿತು ಈಡಾಗುತ್ತಾರೆ.

487
00:26:55,000 --> 00:26:59,000
ಆದರೆ ಎಡ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ವಿಷಯ ವಿಶೇಷ ಅಸ್ಥಿರವಾಗಿದೆ.

488
00:26:59,000 --> 00:27:02,000
ಏಕೆಂದರೆ ಒಂದು gotcha ಇದು ಒಂದು ಪಾಯಿಂಟರ್ ಎಂದು ವಿಶೇಷವೇನು

489
00:27:02,000 --> 00:27:04,000
ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯನ್ನು, ಈ ವಿಷಯಗಳನ್ನು ಕರೆಯಲಾಗುವ

490
00:27:04,000 --> 00:27:09,000
ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ಮೇಲೆ ಸ್ಥಗಿತಗೊಳ್ಳಲು ಹೊಂದಿರುತ್ತವೆ.

491
00:27:09,000 --> 00:27:13,000
>> ಕೇವಲ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಇದ್ದಂತೆ, ನೀವು ಮೊದಲ ಚಾರ್ ವಿಳಾಸವನ್ನು ತಿಳಿಯಲು ಹೊಂದಿರುತ್ತವೆ.

492
00:27:13,000 --> 00:27:15,000
ಸಂಬಂಧಿತ ಪಟ್ಟಿಗಳನ್ನು ಅದೇ ಒಪ್ಪಂದ.

493
00:27:15,000 --> 00:27:19,000
ನೀವು ಮೆಮೊರಿಯ ಮೊದಲ ಚಂಕ್ ವಿಳಾಸವನ್ನು ತಿಳಿಯಲು ಹೊಂದಿವೆ

494
00:27:19,000 --> 00:27:25,000
ಅಲ್ಲಿಂದ ಏಕೆಂದರೆ, ನೀವು ಪ್ರತಿ ಇತರ ಒಂದು ತಲುಪಬಹುದು.

495
00:27:25,000 --> 00:27:27,000
ತೊಂದರೆಯೂ.

496
00:27:27,000 --> 00:27:30,000
ನಾವು ಸಕ್ರಿಯವಾಗಿ ಹೊಂದುವ ಈ ಸರ್ವತೋಮುಖ ಶಕ್ತಿಗಾಗಿ ಏನು ಬೆಲೆ ಪಾವತಿಸುತ್ತಿರುವ

497
00:27:30,000 --> 00:27:34,000
ಗಣನೀಯ ಅಕ್ಷಾಂಶ ರಚನೆ ನಾವು ಇನ್ನಷ್ಟು ಮೆಮೊರಿ ಅಗತ್ಯವಿದ್ದರೆ, ದಂಡ,

498
00:27:34,000 --> 00:27:37,000
ಕೇವಲ ಒಂದು ಪಡೆ ನಿಯೋಜಿಸಲು ಮತ್ತು ಪಾಯಿಂಟರ್ ರಿಂದ ಡ್ರಾ

499
00:27:37,000 --> 00:27:39,000
ಪಟ್ಟಿಯ ಹೊಸ ಬಾಲ ಹಳೆಯ?

500
00:27:39,000 --> 00:27:41,000
ಹೌದು.

501
00:27:41,000 --> 00:27:43,000
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ಎರಡು ಪಟ್ಟು ಹೆಚ್ಚು ಜಾಗವನ್ನು ಆವರಿಸುತ್ತದೆ.

502
00:27:43,000 --> 00:27:45,000
ಇದು ಖಂಡಿತವಾಗಿಯೂ ಒಂದು ಹಿನ್ನಡೆಯೆಂದರೆ ಎಂದು ಆದ್ದರಿಂದ, ಎರಡು ಪಟ್ಟು ಹೆಚ್ಚು ಜಾಗವನ್ನು ಆವರಿಸುತ್ತದೆ, ಮತ್ತು ನಾವು ನೋಡಿದ್ದೇವೆ

503
00:27:45,000 --> 00:27:48,000
ಸಮಯ ಮತ್ತು ಬಾಹ್ಯಾಕಾಶ ಮತ್ತು ನಮ್ಯತೆಯನ್ನು ನಡುವೆ ಮೊದಲು ವಿನಿಯಮವನ್ನು

504
00:27:48,000 --> 00:27:51,000
ಈಗ, ನಾವು ಈ ಸಂಖ್ಯೆಗಳನ್ನು ಪ್ರತಿ 32 ಬಿಟ್ಗಳು ಇಲ್ಲ ಅಲ್ಲಿ.

505
00:27:51,000 --> 00:27:57,000
ನಾವು ನಿಜವಾಗಿಯೂ ಪಾಯಿಂಟರ್ 64, ಸಂಖ್ಯೆ 32 ಮತ್ತು 32 ಅಗತ್ಯವಿದೆ.

506
00:27:57,000 --> 00:27:59,000
ಆದರೆ ಹೇ, ನಾನು RAM ನ 2 ಗಿಗಾಬೈಟ್ ಹೊಂದಿರುತ್ತವೆ.

507
00:27:59,000 --> 00:28:02,000
ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ ಇನ್ನೊಂದು 32 ಬಿಟ್ಗಳು ಸೇರಿಸುವ ಒಂದು ಒಪ್ಪಂದದ ದೊಡ್ಡ ಕಾಣುತ್ತಿಲ್ಲ.

508
00:28:02,000 --> 00:28:05,000
ಆದರೆ ದೊಡ್ಡ ಡೇಟಾ ಸೆಟ್ಗಳನ್ನು ಇದು ಖಂಡಿತವಾಗಿ ಅಕ್ಷರಶಃ ದುಪ್ಪಟ್ಟು ಸೇರಿಸಿ.

509
00:28:05,000 --> 00:28:09,000
ಈಗ ಮತ್ತೊಂದು ಹಿನ್ನಡೆಯೆಂದರೆ ಅವರ, ಅಥವಾ ನಾವು, ಯಾವ ವೈಶಿಷ್ಟ್ಯವು ಬಿಡಲು ಇಲ್ಲ

510
00:28:09,000 --> 00:28:12,000
ನಾವು ಲಿಂಕ್ ಪಟ್ಟಿ ಮತ್ತು ಸಹಿತ ವಸ್ತುಗಳ ಪಟ್ಟಿಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ? ವೇಳೆ

511
00:28:12,000 --> 00:28:14,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಹಿಮ್ಮುಖವಾಗಿ ಸಂಚರಿಸುತ್ತಾರೆ ಸಾಧ್ಯವಿಲ್ಲ.

512
00:28:14,000 --> 00:28:16,000
ನೀವು ಹಿಮ್ಮುಖವಾಗಿ ಸಂಚರಿಸುತ್ತಾರೆ ಸಾಧ್ಯವಿಲ್ಲ, ನೀವು ವಾಕಿಂಗ್ ಬಳಸುತ್ತಿದ್ದರೆ ನೀವು ರೀತಿಯ ಸ್ಕ್ರೆವೆದ್ ಆರ್ ಆದ್ದರಿಂದ

513
00:28:16,000 --> 00:28:19,000
ಎಡದಿಂದ ಬಲಕ್ಕೆ ಲೂಪ್ ಅಥವಾ ಸ್ವಲ್ಪ ಲೂಪ್ ಒಂದು ಬಳಸಿ

514
00:28:19,000 --> 00:28:21,000
ತದನಂತರ ನೀವು "ಓಹ್, ನಾನು ಪಟ್ಟಿ ಆರಂಭಕ್ಕೆ ಹಿಂದಕ್ಕೆ ಹೋಗಲು ಬಯಸುವ.", ಅರ್ಥ

515
00:28:21,000 --> 00:28:26,000
ಬಾಣಗಳು ಸೂಚಿಸುತ್ತವೆ ಎಂದು ನೀವು ಈ ಪಾಯಿಂಟರ್ಸ್ ಮಾತ್ರ ಎಡದಿಂದ ಬಲಕ್ಕೆ ಹೋಗಿ ಸಾಧ್ಯವಿಲ್ಲ.

516
00:28:26,000 --> 00:28:29,000
>> ಈಗ, ನೀವು, ಮತ್ತೊಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಜೊತೆಗೆ ಪಟ್ಟಿಯಲ್ಲಿ ಆರಂಭದಲ್ಲಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

517
00:28:29,000 --> 00:28:31,000
ಆದರೆ ನೆನಪಿಡಿ ಒಂದು ಸಂಕೀರ್ಣತೆ ಇಲ್ಲಿದೆ.

518
00:28:31,000 --> 00:28:35,000
ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ನೀವು ಹೋಗಿ ಹೇಗೆ ದೂರದ ಯಾವುದೇ, ನೀವು ಯಾವಾಗಲೂ, ಮೈನಸ್ ಮೈನಸ್, ಮೈನಸ್ ಮಾಡಿ, ಮೈನಸ್ ಮಾಡಬಹುದು

519
00:28:35,000 --> 00:28:37,000
ಮತ್ತು ನೀವು ಬಂದು ಎಲ್ಲಿಂದ ಮರಳಿ ಹೋಗಿ.

520
00:28:37,000 --> 00:28:40,000
ಮತ್ತೊಂದು ಹಿನ್ನಡೆಯೆಂದರೆ ಇಲ್ಲಿ ಏನಿದೆ? ಹೌದು.

521
00:28:40,000 --> 00:28:43,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ]

522
00:28:43,000 --> 00:28:47,000
ನೀವು, ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಕೇವಲ, ಒಂದು ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿ ಎಂಬ ಅಕ್ಷಾಂಶ ರಚನೆ ಪ್ರಸ್ತಾಪ ಮಾಡಿದ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

523
00:28:47,000 --> 00:28:50,000
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನೀವು ಈ ಆಯತಗಳನ್ನು ಪ್ರತಿಯೊಂದು ಮತ್ತೊಂದು ಪಾಯಿಂಟರ್ ಸೇರಿಸುವುದು

524
00:28:50,000 --> 00:28:53,000
ಇತರ ದಿಕ್ಕಿನಲ್ಲಿ ಸಾಗುತ್ತದೆ, ಮೇಲಿನಿಂದ ಇದರಲ್ಲಿ

525
00:28:53,000 --> 00:28:55,000
ನೀವು ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ಹಾದುಹೋಗುವಂತೆ ಮಾಡಬಹುದು ಈಗ

526
00:28:55,000 --> 00:28:59,000
ನಾವು ಬಳಸುವ ಇದು ಇಳಿಕೆಗಿಂತ ಈಗ ನೀವು ಅಷ್ಟೇ ಸ್ಮರಣೆಯನ್ನು ಮೂರು ಬಾರಿ ಬಳಸುತ್ತಿರುವ ಇದೆ

527
00:28:59,000 --> 00:29:04,000
ಮತ್ತು ನೀವು ಸರಿಯಾದ ಪಡೆಯಲು ಬರೆಯಬೇಕು ಕೋಡ್ ಪರಿಭಾಷೆಯಲ್ಲಿ ಸಂಕೀರ್ಣತೆ ಸೇರಿಸುವ.

528
00:29:04,000 --> 00:29:08,000
ರಿವರ್ಸಲ್ ಹೆಚ್ಚು ಪ್ರಮುಖ ವೇಳೆ ಆದರೆ ಈ ಎಲ್ಲಾ ಬಹುಶಃ ಅತ್ಯಂತ ಸಮಂಜಸವಾದ ರಾಜಿ ವಿನಿಮಯದ ಇವೆ.

529
00:29:08,000 --> 00:29:10,000
ಹೌದು.

530
00:29:10,000 --> 00:29:12,000
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು 2D ಸಂಬಂಧಿಸಿದ ಪಟ್ಟಿಯ ಹೊಂದುವಂತಿಲ್ಲ.

531
00:29:12,000 --> 00:29:16,000
ಉತ್ತಮ, ನೀವು ನಿಜವಾಗಿಯೂ 2D ಲಿಂಕ್ ಪಟ್ಟಿ ಹೊಂದುವಂತಿಲ್ಲ.

532
00:29:16,000 --> 00:29:18,000
ನೀವು ಮಾಡಬಹುದು. ಇದು ಒಂದು ವಿನ್ಯಾಸ ಎಂದು ಸುಮಾರು ಎಂದು ಸುಲಭ ಅಲ್ಲ.

533
00:29:18,000 --> 00:29:21,000
ಒಂದು ರಚನೆಯ ರೀತಿಯಲ್ಲಿ, ನೀವು ತೆರೆದ ಆವರಣ ಚಿಹ್ನೆ, ಮುಚ್ಚಿದ ಆವರಣ ಚಿಹ್ನೆ, ಮುಕ್ತ ಬ್ರಾಕೆಟ್, ಬ್ರಾಕೆಟ್ ಮುಚ್ಚಲಾಯಿತು, ಏನು

534
00:29:21,000 --> 00:29:23,000
ಮತ್ತು ನೀವು ಕೆಲವು 2 ಆಯಾಮದ ರಚನೆಯನ್ನು ಪಡೆಯಿರಿ.

535
00:29:23,000 --> 00:29:26,000
ನೀವು 2 ಆಯಾಮದ ಲಿಂಕ್ ಪಟ್ಟಿ ಜಾರಿಗೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

536
00:29:26,000 --> 00:29:29,000
ನೀವು ಆಡ್-ಎಂದು ನೀವು ಈ ವಿಷಯಗಳನ್ನು ಪ್ರತಿ ಮೂರನೇ ಪಾಯಿಂಟರ್-ಒಂದು ಪ್ರಸ್ತಾಪಿಸಿದರು ಹೋದರೆ

537
00:29:29,000 --> 00:29:34,000
ನೀವು ಇನ್ನೊಂದು ಪಟ್ಟಿ ಬಗ್ಗೆ ನಿಮಗೆ ಅನಿಸಿದರೆ ಮತ್ತು ನೀವು ನಲ್ಲಿ 3D ಶೈಲಿ ಬರುವ

538
00:29:34,000 --> 00:29:40,000
ಪರದೆಯಿಂದ ನಮಗೆ ಎಲ್ಲಾ, ಇದು ಕೆಲವು ರೀತಿಯ ಮತ್ತೊಂದು ಸರಪಳಿ.

539
00:29:40,000 --> 00:29:45,000
ನಾವು ಇದನ್ನು ಮಾಡಬಹುದು, ಆದರೆ ಇದು ಮುಕ್ತ ಬ್ರಾಕೆಟ್, ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಟೈಪ್ ಎಂದು ಸರಳ ಅಲ್ಲ. ಹೌದು.

540
00:29:45,000 --> 00:29:48,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ]

541
00:29:48,000 --> 00:29:50,000
ಗುಡ್, ಆದ್ದರಿಂದ ಈ ಒಂದು ನೈಜ ಒದೆಯುವ ಕುದುರೆ ಹೊಂದಿದೆ.

542
00:29:50,000 --> 00:29:54,000
>> ನಾವು ಬೈನರಿ ಸರ್ಚ್, OH ನಂತಹ ಮೇಲೆ pined ನೀವು ಈ ಕ್ರಮಾವಳಿಗಳು

543
00:29:54,000 --> 00:29:57,000
ನೀವು ಮಂಡಳಿಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹುಡುಕಬಹುದು

544
00:29:57,000 --> 00:30:01,000
ಅಥವಾ ದೂರವಾಣಿ ಪುಸ್ತಕ ತುಂಬಾ ಬೇಗ ನೀವು ಬಳಸುತ್ತಿದ್ದರೆ ವಿಭಜನೆಯನ್ನು ವಶಪಡಿಸಿಕೊಳ್ಳಲು

545
00:30:01,000 --> 00:30:05,000
ಮತ್ತು ಒಂದು ಬೈನರಿ ಸರ್ಚ್ ಕ್ರಮಾವಳಿ, ಆದರೆ ಬೈನರಿ ಸರ್ಚ್ ಎರಡು ಕಲ್ಪನೆಗಳನ್ನು ಅಗತ್ಯ.

546
00:30:05,000 --> 00:30:09,000
ಡೇಟಾ ವಿಂಗಡಿಸಲಾದ ಎಂದು ಒಂದು.

547
00:30:09,000 --> 00:30:11,000
ಈಗ, ನಾವು ಸಂಭಾವ್ಯವಾಗಿ, ಈ ವಿಂಗಡಿಸಲಾದ ಇರಿಸಬಹುದು

548
00:30:11,000 --> 00:30:14,000
ಆದ್ದರಿಂದ ಬಹುಶಃ ಒಂದು ಕಾಳಜಿ ಅಲ್ಲ, ಆದರೆ ಬೈನರಿ ಸರ್ಚ್ ಸಹ ಊಹಿಸಲಾಗಿದೆ

549
00:30:14,000 --> 00:30:18,000
ನೀವು, ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಗೆ ಯಾದೃಚ್ಛಿಕ ಪ್ರವೇಶ ಎಂದು

550
00:30:18,000 --> 00:30:21,000
ಮತ್ತು ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ನೀವು ಯಾದೃಚ್ಛಿಕ ಅವಕಾಶ ನೀಡುತ್ತದೆ, ಮತ್ತು ರ್ಯಾಂಡಮ್ ಆಕ್ಸೆಸ್ ಮೂಲಕ

551
00:30:21,000 --> 00:30:24,000
ನಾನು ನಿಮಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಿದ ಬಳಸುತ್ತಿದ್ದರೆ, ನೀವು ಎಷ್ಟು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಅರ್ಥವನ್ನು

552
00:30:24,000 --> 00:30:26,000
ಬ್ರಾಕೆಟ್ 0 ಪಡೆಯಲು?

553
00:30:26,000 --> 00:30:29,000
ಒಂದು ಕಾರ್ಯಾಚರಣೆಯನ್ನು, ನೀವು [0] ಅನ್ನು ಮತ್ತು ನೀವು ಹಕ್ಕನ್ನು ಅಲ್ಲಿ ಆರ್.

554
00:30:29,000 --> 00:30:33,000
ಸ್ಥಳ 10 ಗೆ ಹೇಗೆ ಅನೇಕ ಕ್ರಮಗಳನ್ನು ಇದು ತೆಗೆದುಕೊಳ್ಳುವುದು?

555
00:30:33,000 --> 00:30:36,000
ಒಂದು ಹಂತದಲ್ಲಿ, ನೀವು ಮತ್ತು ನೀವು ನೀವು [10] ಗೆ ಹೋಗಿ.

556
00:30:36,000 --> 00:30:40,000
ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಹೇಗೆ ನೀವು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ 10 ಪೂರ್ಣಾಂಕದವರೆಗೆ ಸಿಗುತ್ತವೆ?

557
00:30:40,000 --> 00:30:42,000
ನೀವು ಕೇವಲ ವಿಚಾರಿಸಿದಾಗ ಇರುವ ಕಾರಣ ನೀವು ಆರಂಭದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬೇಕು

558
00:30:42,000 --> 00:30:45,000
ಕೇವಲ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಆರಂಭದಲ್ಲಿ, ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಂಡು ಇದೆ

559
00:30:45,000 --> 00:30:48,000
ಅದರ ಮೊದಲ ಚಾರ್ ವಿಳಾಸವನ್ನು ಮೂಲಕ, ಮತ್ತು 10 ಇಂಟ್ ಹೇಗೆ

560
00:30:48,000 --> 00:30:53,000
ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ಆ 10 ನೇ ಅಕ್ಷರ, ನೀವು ಇಡೀ ಡ್ಯಾಮ್ ವಿಷಯ ಹುಡುಕಲು ಹೊಂದಿರುತ್ತವೆ.

561
00:30:53,000 --> 00:30:55,000
>> ಮತ್ತೆ, ನಾವು ನಮ್ಮ ಸಮಸ್ಯೆಗಳನ್ನು ಎಲ್ಲಾ ಪರಿಹರಿಸುವ ಇಲ್ಲ.

562
00:30:55,000 --> 00:31:00,000
ನಾವು ಹೊಸತನ್ನು ಪರಿಚಯಿಸುವ ಮಾಡುತ್ತಿರುವ, ಆದರೆ ಇದು ನಿಜವಾಗಿಯೂ ನಿಮಗೆ ವಿನ್ಯಾಸ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಅವಲಂಬಿಸಿದೆ.

563
00:31:00,000 --> 00:31:04,000
ಈ ಅನುಷ್ಠಾನಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ, ನಾವು ವಿದ್ಯಾರ್ಥಿ ರಚನೆಯನ್ನು ಕಲ್ಪನೆಯನ್ನು ಸಾಲ ಪಡೆಯಬಹುದು.

564
00:31:04,000 --> 00:31:07,000
ವಾಕ್ಯ ಈಗ ಹೊರತುಪಡಿಸಿ, ಹೋಲುತ್ತದೆ, ಕಲ್ಪನೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅಮೂರ್ತವಾಗಿದೆ

565
00:31:07,000 --> 00:31:09,000
ಹೆಚ್ಚು ಮನೆ ಮತ್ತು ಹೆಸರು ಮತ್ತು id.

566
00:31:09,000 --> 00:31:13,000
ಆದರೆ ನಾವು ಸಿ ಡೇಟಾ ರಚನೆ ಹೊಂದಿವೆ ಎಂದು ಸಲಹೆ

567
00:31:13,000 --> 00:31:17,000
ನೋಡ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ, ಸ್ಲೈಡ್ ಕೊನೆಯ ಪದವು ಸೂಚಿಸುವಂತೆ

568
00:31:17,000 --> 00:31:21,000
ಒಂದು ನೋಡ್ ಒಳಗೆ, ಮತ್ತು ಒಂದು ನೋಡ್ ಕೇವಲ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಒಂದು ಜೆನೆರಿಕ್ ಧಾರಕವಾಗಿದೆ.

569
00:31:21,000 --> 00:31:25,000
ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ವಲಯಕ್ಕೆ ಅಥವಾ ನಾವು ಮಾಡಿದ ಒಂದು ಚದರ ಅಥವಾ ಆಯತ ಮಾಹಿತಿ ಡ್ರಾ ಮಾಡಿದ.

570
00:31:25,000 --> 00:31:27,000
ಈ ವಿನ್ಯಾಸ, ನಾವು ಒಂದು int, N, ಹೊಂದಿವೆ

571
00:31:27,000 --> 00:31:29,000
ಆದ್ದರಿಂದ ನಾನು ಶೇಖರಿಸಿಡಲು ಬಯಸುವ ಸಂಖ್ಯೆಯ.

572
00:31:29,000 --> 00:31:36,000
ಆದರೆ ಈ ಎರಡನೇ ಸಾಲು, struct ನೋಡ್ * ಮುಂದಿನ ಏನು?

573
00:31:36,000 --> 00:31:40,000
ಏಕೆ, ಇದು ಸರಿಯೇ, ಅಥವಾ ಪಾತ್ರ ಈ ವಿಷಯ ನಾಟಕದ ಏನು

574
00:31:40,000 --> 00:31:42,000
ಅದು ಮೊದಲ ನೋಟದಲ್ಲಿ ಸ್ವಲ್ಪ ರಹಸ್ಯ ಇಲ್ಲಿದೆ ಸಹ?

575
00:31:42,000 --> 00:31:44,000
ಹೌದು.

576
00:31:44,000 --> 00:31:46,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

577
00:31:46,000 --> 00:31:50,000
ನಿಖರವಾಗಿ, ಆದ್ದರಿಂದ ಇದು ಕೆಲವು ವಿಧದ ಪಾಯಿಂಟರ್ ಕೊಂಡೊಯ್ಯುವ ಆಫ್ * ರೀತಿಯ ಎಂದು.

578
00:31:50,000 --> 00:31:53,000
ಈ ಪಾಯಿಂಟರ್ ಹೆಸರು, ಕ್ರಮವಿಲ್ಲದ ಮುಂದಿನ

579
00:31:53,000 --> 00:32:00,000
ಆದರೆ ಅದನ್ನು ನಾವು ನೀವು ಏನು ಎಂದು, ಆದರೆ ಈ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟ್ ಏನು ಮಾಡುತ್ತದೆ?

580
00:32:00,000 --> 00:32:03,000
[ವಿದ್ಯಾರ್ಥಿ] ಇನ್ನೊಂದು ನೋಡ್. >> ನಿಖರವಾಗಿ, ಇದು ಇನ್ನೊಂದು ನೋಡ್ ಸೂಚಿತವಾಗಿರುತ್ತದೆ.

581
00:32:03,000 --> 00:32:05,000
>> ಈಗ, ಈ ಸಿ ಒಂದು ಕುತೂಹಲದ ತೆರನಾದ

582
00:32:05,000 --> 00:32:09,000
, ಸಿ ಎಡದಿಂದ ಬಲಕ್ಕೆ, ಕೆಳಗೆ ಒಂದು ಕಂಪೈಲರ್ ಅಗ್ರ ಓದಲ್ಪಟ್ಟಿತೆಂದರೆ ಸ್ಮರಿಸುತ್ತಾರೆ

583
00:32:09,000 --> 00:32:13,000
ಇದು ನಾವು ವಿದ್ಯಾರ್ಥಿ ಏನು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ ಅರ್ಥ.

584
00:32:13,000 --> 00:32:16,000
ನಾವು ವಿದ್ಯಾರ್ಥಿ ವಿವರಿಸಿದಾಗ, ನಾವು ನಿಜವಾಗಿಯೂ ಅಲ್ಲಿ ಒಂದು ಪದ ಪುಟ್ ಮಾಡಲಿಲ್ಲ.

585
00:32:16,000 --> 00:32:18,000
ಇದು ಕೇವಲ typedef ಹೇಳಿದರು.

586
00:32:18,000 --> 00:32:20,000
ನಂತರ ನಾವು ಇಂಟ್ ಐಡಿ, ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು, ಸ್ಟ್ರಿಂಗ್ ಮನೆ, ಹೊಂದಿತ್ತು

587
00:32:20,000 --> 00:32:23,000
ತದನಂತರ struct ಕೆಳಭಾಗದಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿ.

588
00:32:23,000 --> 00:32:26,000
ಈ ಘೋಷಣೆಯ ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಏಕೆಂದರೆ,

589
00:32:26,000 --> 00:32:28,000
ಮತ್ತೆ, C ಕಂಪೈಲರ್ ಸ್ವಲ್ಪ ಮೂಕ ಹೊಂದಿದೆ.

590
00:32:28,000 --> 00:32:30,000
ಇದು ಕೇವಲ, ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಓದಲು ವಿಶೇಷವೇನು

591
00:32:30,000 --> 00:32:33,000
ಇಲ್ಲಿ 2 ನೇ ಸಾಲಿನ ತಲುಪುತ್ತದೆ ಹಾಗಿದ್ದಲ್ಲಿ

592
00:32:33,000 --> 00:32:37,000
ಮುಂದಿನ ಡಿಕ್ಲೇರ್ಡ್ ಮತ್ತು ನೋಡುವ ಅಲ್ಲಿ, OH ಇಲ್ಲಿ ಮುಂದಿನ ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಇಲ್ಲಿದೆ.

593
00:32:37,000 --> 00:32:39,000
ಇದು ಒಂದು struct ನೋಡ್ಗೆ ಒಂದು ಪಾಯಿಂಟರ್ ಇಲ್ಲಿದೆ.

594
00:32:39,000 --> 00:32:42,000
ಕಂಪೈಲರ್ ಒಂದು struct ನೋಡ್ ಅರಿತುಕೊಳ್ಳುವುದಕ್ಕೆ ಹೋಗುವ ಇದೆ?

595
00:32:42,000 --> 00:32:44,000
ನಾನು ಮೊದಲು ಈ ವಿಷಯ ಕೇಳಿದ ನಾನೆಂದಿಗೂ

596
00:32:44,000 --> 00:32:47,000
ಪದ ನೋಡ್ ಮೇಲಿಂಗ್ ಕಾಣಿಸದೇ ಇರಬಹುದು ಏಕೆಂದರೆ

597
00:32:47,000 --> 00:32:49,000
ಕೆಳಗಿನ ತನಕ ಈ ಪುನರುಕ್ತಿ ಇಲ್ಲ.

598
00:32:49,000 --> 00:32:53,000
ನೀವು ನಂತರ ಮೇಲೆ ಕಡಿಮೆ ಮಾಡಬಹುದು, ಇಲ್ಲಿ struct ನೋಡ್ ಹೇಳಬೇಕೆಂದು

599
00:32:53,000 --> 00:32:56,000
ಕೆಳಗೆ ಇಲ್ಲಿ typedef ಧನ್ಯವಾದಗಳು, ಆದರೆ ಈ ಕಾರಣ

600
00:32:56,000 --> 00:33:02,000
ನಾವು ಒಳಗೆ ರಚನೆಯ ವಿನ್ಯಾಸವನ್ನು ಸ್ವತಃ ಉಲ್ಲೇಖಗಳನ್ನು ನೀಡಲಾಗಿದೆ.

601
00:33:02,000 --> 00:33:05,000
ಯಾವುದೇ ಒಂದು gotcha ಇಲ್ಲಿದೆ.

602
00:33:05,000 --> 00:33:07,000
>> ಕೆಲವು ಆಸಕ್ತಿದಾಯಕ ಸಮಸ್ಯೆಗಳು ಏಳುತ್ತವೆ ಹೋಗುವ.

603
00:33:07,000 --> 00:33:09,000
ನಾವು ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಮಾಡಲೇಬೇಕು. ನಾವು ಇದನ್ನು ಹೇಗೆ ಸೇರಿಸಲು ಇಲ್ಲ?

604
00:33:09,000 --> 00:33:11,000
ಹೇಗೆ ನಾವು ಹುಡುಕಾಟ? ನಾವು ಅದರಿಂದ ಹೇಗೆ ಅಳಿಸಲು ನೀವು?

605
00:33:11,000 --> 00:33:13,000
ವಿಶೇಷವಾಗಿ ಈಗ ನಾವು ಈ ಪಾಯಿಂಟರ್ಗಳ ಎಲ್ಲಾ ನಿರ್ವಹಿಸಲು ಹೊಂದಿವೆ.

606
00:33:13,000 --> 00:33:15,000
ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಮನಸ್ಸು ತಲ್ಲೀನವಾಗಿ ರೀತಿಯ ಎನಿಸಿದ

607
00:33:15,000 --> 00:33:17,000
ನೀವು ಹೊಂದಿತ್ತು ಅವುಗಳನ್ನು ಒಂದು ಅದನ್ನು ಒಂದು ಇಂಟ್ ಓದಲು ಪ್ರಯತ್ನಿಸುವಾಗ.

608
00:33:17,000 --> 00:33:20,000
ಈಗ ನಾವು ಒಂದು ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಯೋಗ್ಯವಾದ ಕುಶಲತೆಯಿಂದ ಹೊಂದಿರುತ್ತವೆ.

609
00:33:20,000 --> 00:33:22,000
ಏಕೆ ನಾವು ಇಲ್ಲಿ ನಮ್ಮ 5 ನಿಮಿಷಗಳ ಬಿಡುವು ಇಲ್ಲ, ಮತ್ತು ನಂತರ ನಾವು ತರುತ್ತೇನೆ

610
00:33:22,000 --> 00:33:34,000
ವೇದಿಕೆಯ ಮೇಲೆ ಕೆಲವು ಜನರಾಗಿದ್ದರು ನಿಖರವಾಗಿ ಮಾಡಲು.

611
00:33:34,000 --> 00:33:36,000
>> ಸಿ ಔಟ್ ನಟಿಸಿದ ನಂತರ ಹೆಚ್ಚು ತಮಾಷೆಯಾಗಿವೆ ಎಂದು.

612
00:33:36,000 --> 00:33:39,000
ಯಾರು ಅಕ್ಷರಶಃ ಮೊದಲ ಎಂದು ಬಯಸುತ್ತೀರಿ?

613
00:33:39,000 --> 00:33:41,000
ಸರಿ, ಅಪ್ ಮೇಲೆ ಬರುತ್ತಾರೆ. ನೀವು ಮೊದಲು.

614
00:33:41,000 --> 00:33:44,000
ಯಾರು 9 ಎಂದು ಬಯಸುತ್ತೀರಿ? ಸರಿ, 9.

615
00:33:44,000 --> 00:33:46,000
ಹೇಗೆ 9? 17?

616
00:33:46,000 --> 00:33:51,000
ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಕೂಟವು. ಆ ಮುಂದಿನ ಸಾಲಿನಲ್ಲಿ 22 ಮತ್ತು 26.

617
00:33:51,000 --> 00:33:53,000
ತದನಂತರ ಯಾರಾದರೂ ಬಗ್ಗೆ ಕ್ಕಿಂತಲೂ ಹೇಗೆ ಎಂದು ಸೂಚಿಸಿದರು.

618
00:33:53,000 --> 00:33:57,000
ನೀವು 34 ಇವೆ. ಸರಿ, ಅಪ್ 34, ಬನ್ನಿ.

619
00:33:57,000 --> 00:33:59,000
ಮೊದಲ ಅಲ್ಲಿರುವ ಹೊಂದಿದೆ. ಸರಿ, ನೀವು ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ನಾಲ್ಕು.

620
00:33:59,000 --> 00:34:01,000
ಮತ್ತು ನಾವು 9 ಯಾರು ಹೇಳಲು ಹೋಗಲಿಲ್ಲ?

621
00:34:01,000 --> 00:34:04,000
ನಮ್ಮ 9 ಯಾರು?

622
00:34:04,000 --> 00:34:07,000
ನಿಜವಾಗಿಯೂ 9 ಬಯಸುತ್ತಾರೆ? ಸರಿ, 9 ಎಂದು, ಬ.

623
00:34:07,000 --> 00:34:10,000
ಇಲ್ಲಿ ನಾವು ಹೋಗಿ.

624
00:34:10,000 --> 00:34:13,000
34, ನಾವು ನೀವು ಭೇಟಿ ಮಾಡುತ್ತೇವೆ.

625
00:34:13,000 --> 00:34:17,000
ಮೊದಲ ಭಾಗವಾಗಿ ನಿಮ್ಮನ್ನು ಆ ರೀತಿ ಮಾಡಲು ಹೊಂದಿದೆ.

626
00:34:17,000 --> 00:34:21,000
26, 22, 17, ಉತ್ತಮ.

627
00:34:21,000 --> 00:34:25,000
ನಾವು ಒಂದು ಕ್ಷಣದಲ್ಲಿ ನೀವು malloc ಎಂದು ನೀನು ಕಾರಣ ನೀವು, ಬಲಬದಿಗೆ ನಿಲ್ಲಬಹುದು ವೇಳೆ.

628
00:34:25,000 --> 00:34:29,000
>> ಒಳ್ಳೆಯ, ಉತ್ತಮ.

629
00:34:29,000 --> 00:34:32,000
ಸರಿ, ಅತ್ಯುತ್ತಮ, ಆದ್ದರಿಂದ ಅವರ ಪ್ರಶ್ನೆಗಳನ್ನು ಇಲ್ಲಿ ಒಂದೆರಡು ಕೇಳಲು ಅವಕಾಶ.

630
00:34:32,000 --> 00:34:34,000
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಹೆಸರೇನು? >> ಅನಿತಾ.

631
00:34:34,000 --> 00:34:37,000
ಅನಿತಾ, ಸರಿ, ಇಲ್ಲಿ ಕಮ್ ಆನ್ ಓವರ್.

632
00:34:37,000 --> 00:34:41,000
ಅನಿತಾ, ನಮಗೆ ರೀತಿಯ ಮೊದಲ ಒಂದು ಸರಳವಾದ ಪ್ರಶ್ನೆಯನ್ನು ಬಗೆಹರಿಸಲು ಸಹಾಯ ಹೋಗುತ್ತದೆ

633
00:34:41,000 --> 00:34:44,000
ಅದು ಹೇಗೆ ನೀವು ಮೌಲ್ಯವನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ಇಲ್ಲವೋ ಎಂಬುದನ್ನು ಪತ್ತೆ ಇಲ್ಲ ಹೊಂದಿದೆ?

634
00:34:44,000 --> 00:34:48,000
ಈಗ, ಮೊದಲ, ಇಲ್ಲಿ ಲ್ಯೂಕಾಸ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಗಮನಿಸಿ

635
00:34:48,000 --> 00:34:52,000
ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ, ಮತ್ತು ಆದ್ದರಿಂದ ಕಾಗದದ ತನ್ನ ತುಂಡು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಬದಿಗೆ ಹೊಂದಿದೆ

636
00:34:52,000 --> 00:34:55,000
ಇದು ಸಾಕಷ್ಟು ಮಾಹಿತಿ ಎತ್ತರದ ಅಲ್ಲ ಮತ್ತು ಅನೇಕ ಬಿಟ್ಗಳು ಎಂದು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಕಾರಣ

637
00:34:55,000 --> 00:34:58,000
ಸಹ ತಾಂತ್ರಿಕವಾಗಿ ಅವರು ಕೇವಲ ತಿರುಗಿಸಲಾಗುತ್ತದೆ ಕಾಗದದ ಒಂದೇ ಗಾತ್ರ ಹೊಂದಿದೆ.

638
00:34:58,000 --> 00:35:01,000
ಆದರೆ ಅವರು ಒಂದು ಪಾಯಿಂಟರ್ ಮಾತ್ರ 32 ಬಿಟ್ಗಳು, ಎಂದು ಒಂದು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ

639
00:35:01,000 --> 00:35:05,000
ಈ ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ಸೂಚಿಯಾಗಿದೆ ಅರ್ಧದಷ್ಟು ಸಂಖ್ಯೆ ಅರ್ಧದಷ್ಟು ಜನರು 64 ಬಿಟ್ಗಳು, ಅವು.

640
00:35:05,000 --> 00:35:08,000
ಆದರೆ ಪಾಯಿಂಟರ್ ಆದ್ದರಿಂದ, ಚಿತ್ರಿಸಲಾಗಿದೆ ಇಲ್ಲ ನೀವು ಹುಡುಗರಿಗೆ ಸಾಧ್ಯವೋ ಸ್ವಲ್ಪ ವಕ್ರವಾಗಿ ವೇಳೆ

641
00:35:08,000 --> 00:35:12,000
ನಿಮಗೆ ಮುಂದಿನ ವ್ಯಕ್ತಿಯ ಕಡೆ ನಿಮ್ಮ ಎಡಗೈ ಬಳಸಿ.

642
00:35:12,000 --> 00:35:14,000
ಮತ್ತು ನೀವು ಸಂಖ್ಯೆ 34 ಆರ್. ನಿಮ್ಮ ಹೆಸರೇನು?

643
00:35:14,000 --> 00:35:16,000
ಅರಿ.

644
00:35:16,000 --> 00:35:19,000
ಅರಿ, ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಬಲಗೈಯಲ್ಲಿ ಕಾಗದದ ಹಿಡಿದುಕೊಳ್ಳಿ, ಮತ್ತು ಎಡಗೈ ನೇರ ಕಡಿಮೆಯಾಗುತ್ತದೆ.

645
00:35:19,000 --> 00:35:21,000
ನೀವು ಎಡಭಾಗದಲ್ಲಿರುವ ಶೂನ್ಯ ಪ್ರತಿನಿಧಿಸುತ್ತವೆ.

646
00:35:21,000 --> 00:35:24,000
>> ಈಗ ನಮ್ಮ ಮಾನವ ಚಿತ್ರವನ್ನು ಬಹಳ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ.

647
00:35:24,000 --> 00:35:26,000
ಈ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ ಹೇಗೆ ವಾಸ್ತವವಾಗಿ.

648
00:35:26,000 --> 00:35:29,000
ಮತ್ತು ನಿಮ್ಮ ರೀತಿಯಲ್ಲಿ ನಾನು ಅಲ್ಲ ಆದ್ದರಿಂದ ನೀವು ಸ್ವಲ್ಪ ಈ ರೀತಿಯಲ್ಲಿ ಮುದುರು ಹೇಳಬಹುದು.

649
00:35:29,000 --> 00:35:34,000
ಇಲ್ಲಿ ಅನಿತಾ, ನನಗೆ ಸಂಖ್ಯೆ 22 ಹೇಗೆ

650
00:35:34,000 --> 00:35:40,000
ಆದರೆ ಮಾನವರು ಕಾಗದವನ್ನು ತುಂಡುಗಳಾಗಿ ಅಪ್ ಹಿಡಿದಿಡಲು ಒಂದು ತೊಡಕಾಗಿ ಊಹಿಸುತ್ತವೆ,

651
00:35:40,000 --> 00:35:43,000
ಆದರೆ ಈ ಪಟ್ಟಿ, ಮತ್ತು ನೀವು ಕೇವಲ ಲ್ಯೂಕಾಸ್ ಆರಂಭದಲ್ಲಿ ಹೊಂದಿವೆ

652
00:35:43,000 --> 00:35:46,000
ಅವರು ಅಕ್ಷರಶಃ ಮೊದಲ ಪಾಯಿಂಟರ್ ಕಾರಣ.

653
00:35:46,000 --> 00:35:51,000
ನೀವೇ ಒಂದು ಪಾಯಿಂಟರ್, ಮತ್ತು ಆದ್ದರಿಂದ ನೀವು ತುಂಬಾ ಏನೋ ಕಡೆ ಸಾಮರ್ಥ್ಯ ಭಾವಿಸೋಣ.

654
00:35:51,000 --> 00:35:56,000
ನೀವೇಕೆ ಲ್ಯೂಕಾಸ್ ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ ನಿಖರವಾಗಿ ಎಂಬುದನ್ನು ಸೂಚಿಸುವ ಮೂಲಕ ಆರಂಭಿಸಲು ಇಲ್ಲ?

655
00:35:56,000 --> 00:35:58,000
ಗುಡ್, ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಈ ಔಟ್ ಜಾರಿಗೆ ಅವಕಾಶ.

656
00:35:58,000 --> 00:36:04,000
ಕೇವಲ ಚರ್ಚೆಯ ಸಲುವಾಗಿ, ನನಗೆ ಇಲ್ಲಿ ಖಾಲಿ ಪುಟ ಮೇಲೆಳೆದುಕೊಳ್ಳಲು ಅವಕಾಶ.

657
00:36:04,000 --> 00:36:06,000
ಹೇಗೆ ನಿಮ್ಮ ಕಾಗುಣಿತ ಇಲ್ಲ? >> ಅನಿತಾ.

658
00:36:06,000 --> 00:36:08,000
ಸರಿ, ಅನಿತಾ.

659
00:36:08,000 --> 00:36:18,000
ಲೆಟ್ಸ್ ನೋಡ್ * ಅನಿತಾ = ಲ್ಯೂಕಾಸ್ ಹೇಳಿದ್ದಾರೆ.

660
00:36:18,000 --> 00:36:22,000
ಹಾಗೆಯೇ, ನಾವು ನೀವು ಲ್ಯೂಕಾಸ್ ಕರೆ ಮಾಡಬೇಕು. ನೀವು ಮೊದಲ ಕರೆ ಮಾಡಬೇಕು.

661
00:36:22,000 --> 00:36:25,000
ಏಕೆ ಈ ಇಲ್ಲಿ ರಿಯಾಲಿಟಿ ಸ್ಥಿರವಾದ ವಾಸ್ತವವಾಗಿ?

662
00:36:25,000 --> 00:36:27,000
ಒಂದು, ಮೊದಲ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

663
00:36:27,000 --> 00:36:30,000
ಮೊದಲ ಎಲ್ಲೋ ಅಪ್ ಇಲ್ಲಿ ಸಂಭಾವ್ಯವಾಗಿ ಮಂಜೂರು ಮಾಡಲಾಗಿದೆ.

664
00:36:30,000 --> 00:36:35,000
ನೋಡ್ * ಮೊದಲ, ಮತ್ತು ಅದನ್ನು ಹೇಗಾದರೂ ಪಟ್ಟಿಯನ್ನು ಹಂಚಿಕೆ ಮಾಡಲಾಗಿದೆ.

665
00:36:35,000 --> 00:36:37,000
ನಾನು ಸಂಭವಿಸಿದ ಹೇಗೆ ಗೊತ್ತಿಲ್ಲ. ವರ್ಗ ಮೊದಲು ಅದು ಸಂಭವಿಸಿತು.

666
00:36:37,000 --> 00:36:40,000
ಮಾನವರಲ್ಲಿ ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ರಚಿಸಲಾಗಿದೆ.

667
00:36:40,000 --> 00:36:44,000
ಈಗ ಕಥೆ ಈ ಎಲ್ಲಾ ಸ್ಪಷ್ಟವಾಗಿ ಫೇಸ್ಬುಕ್ ನಡೆಯುತ್ತಿರುವ ಈ ಹಂತದಲ್ಲಿ ನಂತರ-

668
00:36:44,000 --> 00:36:49,000
ಕಥೆಯಲ್ಲಿ ಈ ಹಂತದಲ್ಲಿ, ಅನಿತಾ, ಮೊದಲ ಸಮಾನವಾಗಿರುತ್ತದೆ ಎಂದು ಆರಂಭಗೊಂಡಿದೆ

669
00:36:49,000 --> 00:36:51,000
ಅದು ಲ್ಯೂಕಾಸ್ ನಲ್ಲಿ ಅನಿತಾ ಅಂಕಗಳನ್ನು ಎಂದು ಅರ್ಥವಲ್ಲ.

670
00:36:51,000 --> 00:36:53,000
ಬದಲಿಗೆ, ಅವರು ಎನ್ನುವುದನ್ನು ಸೂಚಿಸುತ್ತಿದೆ ಏನು ಎನ್ನುವುದನ್ನು ಸೂಚಿಸುತ್ತಿದೆ

671
00:36:53,000 --> 00:36:57,000
ಏಕೆಂದರೆ ಲ್ಯೂಕಾಸ್ನ 32 ಬಿಟ್ಸ್ ಒಳಗೆ ಎಂದು ಅದೇ ವಿಳಾಸಕ್ಕೆ - 1, 2, 3 -

672
00:36:57,000 --> 00:37:01,000
1, 2, 3 - ಈಗ ಒಳಗೆ ಅನಿತಾ ಅವರ 32 ಬಿಟ್ಗಳನ್ನು ಹೊಂದಿದೆ.

673
00:37:01,000 --> 00:37:05,000
>> ಈಗ 22 ಹೇಗೆ. ನೀವು ಈ ರೀತಿ ಸುಮಾರು ಹೋಗುತ್ತಾರೆ?

674
00:37:05,000 --> 00:37:07,000
ಏನೇ ಆ? >> ಪಾಯಿಂಟ್ ಏನಿದೆ.

675
00:37:07,000 --> 00:37:11,000
ಯಾವುದೇ ದೃಷ್ಟಿಕೋನದಲ್ಲಿ, ಆದ್ದರಿಂದ ಮುಂದುವರಿಯಿರಿ ಮತ್ತು ನೀವು ಇಲ್ಲಿ ಅತ್ಯುತ್ತಮ ಎಂದು ವರ್ತಿಸಬೇಕು.

676
00:37:11,000 --> 00:37:15,000
, ಉತ್ತಮ ಉತ್ತಮ, ಮತ್ತು ಈಗ ನೀವು ಸೂಚಿಸುವ ನೀವು ಮೇಲೆ ನಿಮ್ಮ ಹೆಸರನ್ನು 22 ಹೊಂದಿರುವ?

677
00:37:15,000 --> 00:37:18,000
ರಾಮನ್. >> ರಾಮನ್, ರಾಮನ್ 22 ಹಿಡಿದುಕೊಂಡು ಆದ್ದರಿಂದ.

678
00:37:18,000 --> 00:37:20,000
ನೀವು ಈಗ ಒಂದು ಚೆಕ್ ಮಾಡಿದ.

679
00:37:20,000 --> 00:37:24,000
ಹಾಗಾಗಿ ರಾಮನ್ == 22, ಮತ್ತು, ಉದಾಹರಣೆಗೆ, ನಾವು ನಿಜವಾದ ಮರಳಬಹುದು ಮಾಡುವುದಿಲ್ಲ.

680
00:37:24,000 --> 00:37:26,000
ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಅವಕಾಶ ಈ ಹುಡುಗರಿಗೆ ವಕ್ರವಾಗಿ-ಸ್ವಲ್ಪ ಇಲ್ಲಿ ನಿಂತು

681
00:37:26,000 --> 00:37:32,000
ಹೇಗೆ ನನಗೆ bool ನಂತಹ ಬೇಗ ಏನಾದರೂ ಮಾಡಿ.

682
00:37:32,000 --> 00:37:37,000
ನಾನು (ನೋಡ್ * ಪಟ್ಟಿ, ಇಂಟ್ N) ಮುಂದಕ್ಕೆ ಹೋಗಿ ಮತ್ತು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ.

683
00:37:37,000 --> 00:37:39,000
ನಾನು ವ್ಯಕ್ತಿಗಳು ಸೂಕ್ತ ಬರುತ್ತೇವೆ. ನಾನು ಕೆಲವು ಕೋಡ್ ಬರೆಯಬೇಕು.

684
00:37:39,000 --> 00:37:45,000
ಮತ್ತು ಈಗ ನಾನು ಮುಂದೆ ಹೋಗಿ ಈ, ನೋಡ್ * ಅನಿತಾ = ಪಟ್ಟಿ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

685
00:37:45,000 --> 00:37:51,000
ನಾನು ಮುಂದೆ ಹೋಗಿ ಮತ್ತು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ ಸಂದರ್ಭದಲ್ಲಿ (ಅನಿತಾ! = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು).

686
00:37:51,000 --> 00:37:57,000
>> ಇಲ್ಲಿ ರೂಪಕ ಸ್ವಲ್ಪ ವಿಸ್ತರಿಸಲಾಗುವುದಿಲ್ಲ ಇದ್ದಾರೆ, ಆದರೆ (ಅನಿತಾ! = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು), ನಾನು ಏನನ್ನು ಬಯಸುತ್ತೀರಿ ಆದರೆ?

687
00:37:57,000 --> 00:38:03,000
ನಾನು ಗುರುತಿಸಲಾಗುತ್ತಿದೆ ಕೆಲವು ದಾರಿ ಬೇಕಾಗುತ್ತದೆ

688
00:38:03,000 --> 00:38:05,000
ಅನಿತಾ ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಪೂರ್ಣಾಂಕ.

689
00:38:05,000 --> 00:38:08,000
ಹಿಂದೆ, ನಾವು ಒಂದು ನೋಡ್ ಇದು, ರಚನೆಗಳು ಆಗ

690
00:38:08,000 --> 00:38:11,000
ನಾವು ಡಾಟ್ ಸಂಕೇತಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ, ಮತ್ತು ನಾವು ಏನನ್ನಾದರೂ ರೀತಿಯಲ್ಲಿ ಹೇಳುತ್ತಿದ್ದರು

691
00:38:11,000 --> 00:38:15,000
ಇಲ್ಲಿ anita.n, ಆದರೆ ಸಮಸ್ಯೆ ಅನಿತಾ ಒಂದು struct ಪ್ರತಿ ಸೆ ಹೇಳಿದ್ದಾರೆ.

692
00:38:15,000 --> 00:38:17,000
ಆಕೆ ಏನು?

693
00:38:17,000 --> 00:38:21,000
ಈ ಬಿಂದುವನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ ಅವರು, ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ಒಂದು ಪಾಯಿಂಟರ್ ಅಂಕನ ಪದ್ಧತಿ-

694
00:38:21,000 --> 00:38:23,000
ಮತ್ತು ಈ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಕಡಿಮೆ ನೋಡಲು ಹೋಗುತ್ತದೆ ರಹಸ್ಯ-

695
00:38:23,000 --> 00:38:28,000
ನಾವು ಏನೇ ಅನಿತಾ ಅವರ ಎಡಗೈ ಹೋಗಿ ಹಾಗೆ ಏನನ್ನಾದರೂ ಮಾಡಬೇಕು ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ

696
00:38:28,000 --> 00:38:31,000
ತದನಂತರ N ಎಂಬ ಕ್ಷೇತ್ರದಲ್ಲಿ ಪಡೆಯಿರಿ.

697
00:38:31,000 --> 00:38:35,000
ಅನಿತಾ ಒಂದು ಪಾಯಿಂಟರ್, ಆದರೆ * ಅನಿತಾ ಏನು?

698
00:38:35,000 --> 00:38:38,000
ನೀವು ಅನಿತಾ ನಲ್ಲಿ ತೋರಿಸುವ ಯಾವ ಹೋಗಿ ನೀವು ಏನನ್ನು ಹೇಗೆ ಏನು?

699
00:38:38,000 --> 00:38:42,000
ಎ struct, ಒಂದು ನೋಡ್, ಮತ್ತು ಒಂದು ನೋಡ್, ಮರುಸ್ಥಾಪನೆ, n ಎಂಬ ಕ್ಷೇತ್ರ

700
00:38:42,000 --> 00:38:47,000
ಇದು ನೆನಪಿಗೆ ಕಾರಣ, ಈ 2 ಜಾಗ, ಮುಂದಿನ ಮತ್ತು N,

701
00:38:47,000 --> 00:38:50,000
ನಾವು ಇಲ್ಲಿಯೇ ಕೊಂಚ ಹಿಂದೆ ನೋಡಿದ.

702
00:38:50,000 --> 00:38:53,000
>> ವಾಸ್ತವವಾಗಿ, ಕೋಡ್ ಈ ಅನುಕರಿಸಲು

703
00:38:53,000 --> 00:39:02,000
ನಾವು ಇದನ್ನು ಮತ್ತು ಹೇಳಬಹುದು ವೇಳೆ ((* ಅನಿತಾ). N == N), ನಾನು ಬಯಸುತ್ತೇನೆ ಎಂದು ಎನ್.

704
00:39:02,000 --> 00:39:04,000
ಕಾರ್ಯ ನಾನು ಕಾಳಜಿ ಸಂಖ್ಯೆಯಲ್ಲಿ ಅಂಗೀಕರಿಸಿತು ಗಮನಿಸಿ.

705
00:39:04,000 --> 00:39:10,000
ನಂತರ ನಾನು ನಿಜವಾದ ಲಾಭ ಸ್ವಲ್ಪ ಮುಂದೆ ಹೋಗಿ ಮಾಡಬಹುದು.

706
00:39:10,000 --> 00:39:12,000
ಆ ಸಂದರ್ಭದಲ್ಲಿ ಅಲ್ಲ ವೇಳೆ ಎಲ್ಸ್, ನಾನು ಏನನ್ನು ಬಯಸುತ್ತೀರಿ?

707
00:39:12,000 --> 00:39:19,000
ನಾನು ಅನಿತಾ ಪಟ್ಟಿಯಲ್ಲಿ ಮೂಲಕ ವಾಕಿಂಗ್ ಹಾಗೆ ಅಂತರ್ಬೋಧೆಯಿಂದ ಏನು ಕೋಡ್ ಗೆ ಭಾಷಾಂತರಿಸಿ ಇಲ್ಲ?

708
00:39:19,000 --> 00:39:26,000
ನಾನು ಅನಿತಾ ಎಡಕ್ಕೆ, ಎಡ ಎಂದು ಹೆಜ್ಜೆ ಎಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಳ್ಳುವ ಅನುಕರಿಸಲು ಇಲ್ಲಿ ಏನು ಮಾಡಬೇಕು?

709
00:39:26,000 --> 00:39:28,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ] >> ಅದು ಯಾವುದು?

710
00:39:28,000 --> 00:39:30,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

711
00:39:30,000 --> 00:39:34,000
, ಒಂದು ಕೆಟ್ಟ ಕಲ್ಪನೆ, ಆದರೆ ಹಿಂದೆ, ನಾವು ಮಾಡಿದ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಉತ್ತಮ ಮಾಡಿದ ಅನಿತಾ + +

712
00:39:34,000 --> 00:39:37,000
ಎಂದು ಅನಿತಾ ಗೆ ಸಂಖ್ಯೆ 1 ಸೇರಿಸಲು ಏಕೆಂದರೆ,

713
00:39:37,000 --> 00:39:40,000
ಇದು ವಿಶಿಷ್ಟವಾಗಿ, ರಾಮನ್ ಹಾಗೆ, ಮುಂದಿನ ವ್ಯಕ್ತಿಯು ನಲ್ಲಿ ತೋರುವುದು

714
00:39:40,000 --> 00:39:44,000
ಅಥವಾ ಅವರಿಗೆ ಮುಂದಿನ ವ್ಯಕ್ತಿ, ಅಥವಾ ವ್ಯಕ್ತಿ ಕೆಳಗೆ ಲೈನ್ ಅವರಿಗೆ ಮುಂದಿನ.

715
00:39:44,000 --> 00:39:49,000
ಏನು ಈ ವಿಷಯ ನೆನಪಿಗಾಗಿ ಕಾಣುತ್ತವೆ ಏಕೆಂದರೆ ಆದರೆ ಇಲ್ಲಿ ಸಾಕಷ್ಟು ಉತ್ತಮ ಅಲ್ಲ?

716
00:39:49,000 --> 00:39:54,000
ಆ. ನಾವು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

717
00:39:54,000 --> 00:40:00,000
ನಾನು 1 ಮತ್ತು 2 ಮತ್ತು 3 ನಿಕಟ ಪರಸ್ಪರ, ಡ್ರಾ ಮಾಡಿದ ಸಹ ನೆನಪಿಗಾಗಿ ಈ ಕಾಣುತ್ತದೆ, ಮತ್ತು

718
00:40:00,000 --> 00:40:03,000
ನಾವು ಅನುಕರಿಸಲು ವೇಳೆ ಅದೇ ಜನ ತೋರುಗಡ್ಡಿ ಮಾಡುವಾಗ ನೀವು, ಹುಡುಗರಿಗೆ ಈ-ಮಾಡಬಹುದು

719
00:40:03,000 --> 00:40:07,000
ನೀವು ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಹೆಜ್ಜೆ ಹಿಂದೆ, ಮುಂದೆ ನೀವು ಕೆಲವು ಯಾದೃಚ್ಛಿಕ ಹಂತದ ತೆಗೆದುಕೊಳ್ಳಬಹುದು?

720
00:40:07,000 --> 00:40:10,000
>> ಈ ಅವ್ಯವಸ್ಥೆ, ಇನ್ನೂ ಲಿಂಕ್ ಪಟ್ಟಿ

721
00:40:10,000 --> 00:40:13,000
ಆದರೆ ಈ ಎಲ್ಲ ವ್ಯಕ್ತಿಗಳು, ಎಲ್ಲಿಯಾದರೂ ನೆನಪಿಗಾಗಿ ಆಗಿರಬಹುದು

722
00:40:13,000 --> 00:40:15,000
ಆದ್ದರಿಂದ ಅನಿತಾ + + ಏಕೆ ಕೆಲಸಕ್ಕೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ?

723
00:40:15,000 --> 00:40:19,000
ಸ್ಥಳ ಅನಿತಾ ನಲ್ಲಿ ಯಾವುದು + +?

724
00:40:19,000 --> 00:40:21,000
ತಿಳಿದಿರುವ.

725
00:40:21,000 --> 00:40:24,000
ಇದು ಕೇವಲ ಆದ್ದರಿಂದ ಇಂಟರ್ಪೊಸ್ಡ್ ಮನೆಯಿದ್ದ ಕೆಲವು ಮೌಲ್ಯವೇನು

726
00:40:24,000 --> 00:40:28,000
ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಗ್ರಂಥಿಗಳು ಎಲ್ಲಾ ನಡುವೆ ನಾವು ಒಂದು ವ್ಯೂಹವನ್ನು ಬಳಸಿಕೊಂಡು ಇಲ್ಲ.

727
00:40:28,000 --> 00:40:30,000
ನಾವು ವೈಯಕ್ತಿಕವಾಗಿ ಈ ಗ್ರಂಥಿಗಳು ಪ್ರತಿ ಹಂಚಿಕೆ.

728
00:40:30,000 --> 00:40:32,000
ಸರಿ, ನೀವು ವ್ಯಕ್ತಿಗಳು ನಿಮ್ಮನ್ನು ಹಿಂದಿರುಗಿ ಸ್ವಚ್ಛಗೊಳಿಸಲು ಒಂದು ವೇಳೆ.

729
00:40:32,000 --> 00:40:37,000
ನನ್ನ ಬದಲಿಗೆ ಅನಿತಾ + +, ನಾವು ಬದಲಿಗೆ ಏನು ಅನಿತಾ ಆ ಪ್ರಸ್ತಾಪಿಸಲು ಅವಕಾಶ ಪಡೆಯುತ್ತದೆ-

730
00:40:37,000 --> 00:40:42,000
ಹಾಗೆಯೇ, ನಾವು ನಂತರ ಅನಿತಾ ನಲ್ಲಿ ಸೂಚಿಸುವ ಯಾವುದೇ ಹೋಗಿ ಮತ್ತು ಏಕೆ. ಮುಂದಿನ?

731
00:40:42,000 --> 00:40:45,000
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾವು ಸಂಖ್ಯೆ 22 ಹೊಂದಿರುವ ಯಾರು ರಾಮನ್, ಹೋಗಿ

732
00:40:45,000 --> 00:40:51,000
ಅನಿತಾ ಅವರ ಎಡಗೈ ಪಾಯಿಂಟರ್ ನಕಲು ಎಂದು ಭಾವಿಸಿ ಮತ್ತು ನಂತರ. ಮುಂದಿನ ಹೊಂದಿದೆ.

733
00:40:51,000 --> 00:40:54,000
ನಾವು 22 ಕಂಡುಬಂದಿಲ್ಲ ಏಕೆಂದರೆ ಆದರೆ ರಾಮನ್ ಹೆಚ್ಚು ದೂರಕ್ಕೆ ಹೋಗಿ ಎಂದು.

734
00:40:54,000 --> 00:40:56,000
ಆದರೆ ಕಲ್ಪನೆ ಎಂದು. ಈಗ, ಈ ಒಂದು ಅತಿಭಯಂಕರವಾದ ಅವ್ಯವಸ್ಥೆ ಆಗಿದೆ.

735
00:40:56,000 --> 00:40:59,000
ಪ್ರಾಮಾಣಿಕವಾಗಿ, ಯಾರೂ, ಆದ್ದರಿಂದ thankfully ಈ ವಾಕ್ಯ ನೆನಪು, ಮತ್ತು

736
00:40:59,000 --> 00:41:04,000
ನಿಜವಾಗಿ ಸ್ವಲ್ಪ ಉದ್ದೇಶಪೂರ್ವಕ-OH, ನಿಜವಾಗಿಯೂ ನಾನು ಬರೆದದ್ದು ಕಂಡಿರಲಿಲ್ಲ ಇಲ್ಲಿದೆ.

737
00:41:04,000 --> 00:41:08,000
ನೀವು ಸಾಧ್ಯವಾದರೆ ಈ ಹೆಚ್ಚು ಬಲವಾದ ಎಂದು. Voila!

738
00:41:08,000 --> 00:41:10,000
>> ತೆರೆಯ ಹಿಂದೆ, ನಾನು ಸಮಸ್ಯೆಯನ್ನು ಈ ರೀತಿಯಲ್ಲಿ ಪರಿಹರಿಸುವ ಮಾಡಲಾಯಿತು.

739
00:41:10,000 --> 00:41:14,000
ಅನಿತಾ, ಎಡ ಎಂದು ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಳ್ಳುವ,

740
00:41:14,000 --> 00:41:18,000
ಮೊದಲ, ನಾವು ಅನಿತಾ ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ವಿಳಾಸಕ್ಕೆ ಹೋಗಿ ಇಲ್ಲ

741
00:41:18,000 --> 00:41:23,000
ಮತ್ತು ಅಲ್ಲಿ ಅವರು ಕೇವಲ ನಾವು ಹೋಲಿಕೆ ಕಲೆಗೋಸ್ಕರ ಪರಿಶೀಲಿಸಿದ ಇದು N, ಕಾಣಬಹುದು

742
00:41:23,000 --> 00:41:25,000
ಆದರೆ ನೀವು ಮುಂದಿನ ಕಾಣುವಿರಿ - ಈ ಸಂದರ್ಭದಲ್ಲಿ,

743
00:41:25,000 --> 00:41:28,000
ರಾಮನ್ ಅವರ ಎಡಗೈ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದಿನ ನೋಡ್ ಸೂಚಿಸುತ್ತಿದ್ದರು.

744
00:41:28,000 --> 00:41:32,000
ಆದರೆ, ಇದು ನಾನು ಹಿಂದಿನ ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ ಗೆ ಅತಿಭಯಂಕರವಾದ ಅವ್ಯವಸ್ಥೆ ಆಗಿದೆ

745
00:41:32,000 --> 00:41:34,000
ಸಿ ಈ ಸರಳಗೊಳಿಸುವ ಅನುಮತಿಸುತ್ತದೆ ಔಟ್ ಆದರೆ ತಿರುಗುತ್ತದೆ.

746
00:41:34,000 --> 00:41:40,000
ಬದಲಿಗೆ ಬರವಣಿಗೆಯ (* ಅನಿತಾ), ನಾವು ಬದಲಿಗೆ ಕೇವಲ, ಅನಿತಾ-> N ಬರೆಯಬಹುದು

747
00:41:40,000 --> 00:41:45,000
ಮತ್ತು, ಇದು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನಿಖರ ಅದೇ ವಿಷಯ, ಆದರೆ ಬಹಳಷ್ಟು ಮತ್ತಷ್ಟು ಗ್ರಹಿಸುವಂತೆ ಇಲ್ಲಿದೆ

748
00:41:45,000 --> 00:41:48,000
ಮತ್ತು ನಾವು ಡ್ರಾಯಿಂಗ್ ಮಾಡಲಾಗಿದೆ ಎಂಬುದನ್ನು ಚಿತ್ರ ಸಾಕಷ್ಟು ಹೆಚ್ಚು ಸ್ಥಿರವಾದ ಇಲ್ಲಿದೆ

749
00:41:48,000 --> 00:41:50,000
ಎಲ್ಲಾ ಆ ಬಾಣಗಳನ್ನು ಬಳಸಿ.

750
00:41:50,000 --> 00:41:57,000
>> ಕೊನೆಯದಾಗಿ, ಈ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ ಮಾಡಲು ಏನು ಬೇಕು?

751
00:41:57,000 --> 00:42:00,000
ಉಳಿದ ಕೋಡ್ ಒಂದು ಲೈನ್ ಇಲ್ಲ.

752
00:42:00,000 --> 00:42:02,000
ಯಾವ ಹಿಂತಿರುಗಿ?

753
00:42:02,000 --> 00:42:05,000
ತಪ್ಪು, ಏಕೆಂದರೆ ನಾವು ಇಡೀ ಮೂಲಕ ಪಡೆಯಲು ವೇಳೆ ಸಮಯದಲ್ಲಿ ಲೂಪ್

754
00:42:05,000 --> 00:42:10,000
ಮತ್ತು ಅನಿತಾ ವಾಸ್ತವವಾಗಿ, ಶೂನ್ಯ, ಆ ಅವಳು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಯಿತು ಎಂದರೆ, ಆಗಿದೆ

755
00:42:10,000 --> 00:42:12,000
ಅವರು ಸೂಚಿಸುವ ಅಲ್ಲಿ ಆ ನಿಮ್ಮ ಹೆಸರು 'ಮತ್ತೆ?

756
00:42:12,000 --> 00:42:15,000
ಶೂನ್ಯ ಇದು ಅರಿ. >> ಅರಿ ನ ಎಡಗೈ,.

757
00:42:15,000 --> 00:42:18,000
ಅನಿತಾ ಈಗ ಶೂನ್ಯ, ಮತ್ತು ನಾನು ನೀವು ಲಿಂಬೊ ರಲ್ಲಿ ವಕ್ರವಾಗಿ ಇಲ್ಲಿ ನಿಂತು ನೀವು ಅರ್ಥ

758
00:42:18,000 --> 00:42:21,000
ನಾನು ಇಲ್ಲಿ ಒಂದು ಸ್ವಗತ ರಂದು ಪಡೆಯಲಿದ್ದೇನೆ ಏಕೆಂದರೆ,

759
00:42:21,000 --> 00:42:23,000
ಆದರೆ ನಾವು ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ಮತ್ತೆ ಒಳಗೊಂಡಿರುತ್ತವೆ ಮಾಡುತ್ತೇವೆ.

760
00:42:23,000 --> 00:42:27,000
ಅನಿತಾ ಕಥೆಯಲ್ಲಿ ಆ ಸಮಯದಲ್ಲಿ ಶೂನ್ಯ ಹೊಂದಿದೆ, ಆದರೆ ಲೂಪ್ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಆದ್ದರಿಂದ

761
00:42:27,000 --> 00:42:30,000
ಮತ್ತು ನಾವು ತಪ್ಪು ಮರಳಲು ಏಕೆಂದರೆ ಅವಳು ಅರಿ ನ ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ದಾರಿ ಸಿಕ್ಕಿತು ವೇಳೆ

762
00:42:30,000 --> 00:42:34,000
ನಂತರ ಅವರು ಪಟ್ಟಿಯಲ್ಲಿ ಬಯಸಿದ್ದರು ಯಾವುದೇ ಸಂಖ್ಯೆಯು ಇರಲಿಲ್ಲ.

763
00:42:34,000 --> 00:42:39,000
ನಾವು ತುಂಬಾ ಅಪ್ ಈ ಸ್ವಚ್ಛಗೊಳಿಸಲು ಸಾಧ್ಯ, ಆದರೆ ಈ ನಂತರ ಒಂದು ಒಳ್ಳೆಯ ಅಳವಡಿಕೆಯಾಗಿದ್ದು

764
00:42:39,000 --> 00:42:43,000
ಒಂದು ಅಡ್ಡಹಾಯುವುದನ್ನು ಕ್ರಿಯೆಯ, ಒಂದು ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಹುಡುಕುತ್ತದೆ.

765
00:42:43,000 --> 00:42:48,000
ಇದು ಇನ್ನೂ ರೇಖೀಯ ಹುಡುಕಾಟ, ಅದು + ಒಂದು ಪಾಯಿಂಟರ್ ಎಂದು ಸರಳ ಅಲ್ಲ

766
00:42:48,000 --> 00:42:52,000
ಅಥವಾ + + ಒಂದು ನಾನು ವೇರಿಯಬಲ್ ಈಗ ನಾವು ಊಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

767
00:42:52,000 --> 00:42:54,000
ಈ ಗ್ರಂಥಿಗಳು ಪ್ರತಿ ನೆನಪಿಗಾಗಿ ಅಲ್ಲಿ ಇವೆ.

768
00:42:54,000 --> 00:42:57,000
ನಾವು ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ, ಅಕ್ಷರಶಃ ಬ್ರೆಡ್ ಕುರಿತು ಅನುಸರಿಸಲು ಅಥವಾ

769
00:42:57,000 --> 00:43:00,000
ಒಂದು ನೋಡ್ ಇನ್ನೊಂದಕ್ಕೆ ಪಡೆಯಲು ಪಾಯಿಂಟರ್ಸ್,.

770
00:43:00,000 --> 00:43:02,000
>> ಈಗ ಮತ್ತೊಂದು ಪ್ರಯತ್ನಿಸೋಣ. ಅನಿತಾ, ನೀವು ಇಲ್ಲಿಗೆ ಹಿಂತಿರುಗಬಹುದು ಬಯಸುತ್ತೀರಿ?

771
00:43:02,000 --> 00:43:06,000
ಏಕೆ ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ ಮತ್ತು ಪ್ರೇಕ್ಷಕರಿಂದ ಇನ್ನೊಬ್ಬ ವ್ಯಕ್ತಿ ನಿಯೋಜಿಸಿ ಇಲ್ಲ?

772
00:43:06,000 --> 00:43:08,000
Malloc-ನಿಮ್ಮ ಹೆಸರು '? >> ರೆಬೆಕಾ.

773
00:43:08,000 --> 00:43:10,000
ರೆಬೆಕ್ಕಾ. ರೆಬೆಕ್ಕಾ, ಪ್ರೇಕ್ಷಕರಿಂದ malloced ಮಾಡಲಾಗಿದೆ

774
00:43:10,000 --> 00:43:13,000
ಈಗ ಅವಳು ಸಂಖ್ಯೆ 55 ಉಳಿಸುವುದು.

775
00:43:13,000 --> 00:43:17,000
ಅನಿತಾ ಸೇರಿಸಲು ಮತ್ತು ಕೈಯಲ್ಲಿ ಗೋಲು ಈಗ

776
00:43:17,000 --> 00:43:22,000
ಅದರ ಸರಿಯಾದ ಸ್ಥಳದಲ್ಲಿ ಇಲ್ಲಿ ಲಿಂಕ್ ಪಟ್ಟಿ ರೆಬೆಕಾ.

777
00:43:22,000 --> 00:43:24,000
ಒಂದು ಕ್ಷಣ ಇಲ್ಲಿ ಕಮ್ ಆನ್ ಓವರ್.

778
00:43:24,000 --> 00:43:28,000
ನಾನು ಈ ರೀತಿಯ ಮಾಡಿದ್ದೇನೆ.

779
00:43:28,000 --> 00:43:32,000
ನಾನು ನೋಡ್ * ಮಾಡಿದ್ದೇನೆ. ಮತ್ತು ನಿಮ್ಮ ಹೆಸರೇನು ಮತ್ತೆ?

780
00:43:32,000 --> 00:43:34,000
ರೆಬೆಕ್ಕಾ. >> ರೆಬೆಕ್ಕಾ, ಸರಿ.

781
00:43:34,000 --> 00:43:41,000
ರೆಬೆಕ್ಕಾ malloc (sizeof (ನೋಡ್)) ಪಡೆಯುತ್ತದೆ.

782
00:43:41,000 --> 00:43:44,000
ಕೇವಲ ನಾವು, ಹಿಂದೆ ವಿದ್ಯಾರ್ಥಿಗಳು ಮತ್ತು ಸ್ಪಷ್ಟವಾಗಿ ವಿವರಿಸಲಾಗದ ಯಾ ಕೆಲಸಕ್ಕೆ ಬಾರದ ವಸ್ತು ವಿಷಯಗಳನ್ನು ಹಂಚಿಕೆ ಮಾಡಿದ್ದಾರೆ

783
00:43:44,000 --> 00:43:46,000
ನಾವು ನೋಡ್ ಗಾತ್ರವನ್ನು ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ಈಗ ರೆಬೆಕಾ

784
00:43:46,000 --> 00:43:49,000
ಎಂಬುದನ್ನು ಸೂಚಿಸುವ ಇದೆ?

785
00:43:49,000 --> 00:43:52,000
ರೆಬೆಕ್ಕಾ 55 ಈ ಪೈಕಿ ತನ್ನ ಒಳಗೆ ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿದೆ.

786
00:43:52,000 --> 00:43:55,000
ಮಾಡೋಣ ಏನನ್ನು, ರೆಬೆಕಾ-> = 55.

787
00:43:55,000 --> 00:44:00,000
ಆದರೆ ನಂತರ ರೆಬೆಕಾ-> ಮುಂದಿನ ಇದೀಗ-ಹೇಗಿರಬೇಕು, ಅವಳ ಕೈ ತಿಳಿದಿರುವ ರೀತಿಯ?

788
00:44:00,000 --> 00:44:03,000
ಅದು ಏಕೆ ಒಳಿತನ್ನು ತರುವುದಕ್ಕಾಗಿ ಹಾಗೆ, ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯದಲ್ಲಿ ತೋರುಗಡ್ಡಿ ವಿಶೇಷವೇನು

789
00:44:03,000 --> 00:44:07,000
ಎಡಗೈ ಈಗ ಅವಳ ಪಕ್ಕದಲ್ಲಿ ಎಂದು ನಾವು ಕನಿಷ್ಠ ಹಾಗೆ.

790
00:44:07,000 --> 00:44:09,000
ಈಗ ಅನಿತಾ, ಇಲ್ಲಿಂದ ತೆಗೆದುಕೊಂಡು.

791
00:44:09,000 --> 00:44:11,000
ನೀವು ರೆಬೆಕಾ ಹಂಚಲಾಗಿತ್ತು ಹೊಂದಿರುತ್ತವೆ.

792
00:44:11,000 --> 00:44:20,000
ಮುಂದೆ ಹೋಗಿ ನಾವು ರೆಬೆಕಾ ತರಬೇಕಿರುವ ಎಲ್ಲಿ.

793
00:44:20,000 --> 00:44:25,000
ಒಳ್ಳೆಯ, ಉತ್ತಮ.

794
00:44:25,000 --> 00:44:28,000
, ಸರಿ, ಉತ್ತಮ, ಮತ್ತು ಈಗ ನೀವು ದಿಕ್ಕಿನ ಬಿಟ್ ಪೂರೈಕೆ

795
00:44:28,000 --> 00:44:30,000
ಆದ್ದರಿಂದ ನೀವು ಅರಿ ತಲುಪಿದ್ದೀರಿ.

796
00:44:30,000 --> 00:44:33,000
ಆತನ ಎಡಗೈ ಶೂನ್ಯ, ಆದರೆ ರೆಬೆಕಾ ಸ್ಪಷ್ಟವಾಗಿ ಬಲ ಸೇರಿದೆ

797
00:44:33,000 --> 00:44:36,000
ಆದ್ದರಿಂದ ನಾವು ಈ ಲಿಂಕ್ ಪಟ್ಟಿ ಬದಲಾಯಿಸಲು ಹೊಂದಿಲ್ಲ

798
00:44:36,000 --> 00:44:38,000
ಸೂಕ್ತ ಸ್ಥಾನಕ್ಕೇರಿತು ರೆಬೆಕಾ ಸೇರಿಸಲು ಸಲುವಾಗಿ?

799
00:44:38,000 --> 00:44:42,000
ನೀವು ಅಕ್ಷರಶಃ ಅಗತ್ಯವಿರುವ ಸುಮಾರು ಜನರ ಎಡ ಕೈ ಸರಿಸಲು ಸಾಧ್ಯವಾದರೆ

800
00:44:42,000 --> 00:44:48,000
ನಾವು ಆ ರೀತಿಯಲ್ಲಿ ಸಮಸ್ಯೆಯನ್ನು ಬಗೆಹರಿಸಲು ನಾವು.

801
00:44:48,000 --> 00:44:52,000
ಸರಿ, ಉತ್ತಮ ಮತ್ತು ಏತನ್ಮಧ್ಯೆ, ರೆಬೆಕ್ಕಾ ಅವರ ಎಡಗೈ ಅವಳ ಅಕ್ಕ ಈಗ.

802
00:44:52,000 --> 00:44:54,000
>> ತೀರಾ ಸುಲಭವಾಗಿತ್ತು.

803
00:44:54,000 --> 00:44:57,000
ಲೆಟ್ಸ್, ಇನ್ನೇನು ಹಂಚುತ್ತಾರೆ-ನಾವು 20 ಪ್ರಯತ್ನಿಸಿ.

804
00:44:57,000 --> 00:44:59,000
ಸರಿ, ಅಪ್ ಮೇಲೆ ಬರುತ್ತಾರೆ.

805
00:44:59,000 --> 00:45:04,000
20 ಮಂಜೂರು ಮಾಡಲಾಗಿದೆ, ಆದ್ದರಿಂದ ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಇಲ್ಲಿ ಮತ್ತೆ ಹೇಳಲು ಅವಕಾಶ

806
00:45:04,000 --> 00:45:07,000
ನಾವು ನೋಡ್ * ಸಾದ್ ಮಾಡಿದ.

807
00:45:07,000 --> 00:45:11,000
ನಾವು (sizeof (ನೋಡ್)) malloc ಹೊಂದಿರುತ್ತವೆ.

808
00:45:11,000 --> 00:45:16,000
ನಾವು ನಂತರ, ನಾವು 20 ಮೊದಲು ಮಾಡಿದರು ಅದೇ ಸರಿಯಾದ ವಾಕ್ಯ ಮಾಡಿ

809
00:45:16,000 --> 00:45:20,000
ಮತ್ತು ನಾನು ಮುಂದಿನ = ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಮಾಡುತ್ತೇನೆ, ಮತ್ತು ಈಗ ಅದು ಅನಿತಾ ಬಿಟ್ಟಿದ್ದು

810
00:45:20,000 --> 00:45:23,000
ನೀವು ಸರಿಯಾದ ಅದೇ ಪಾತ್ರವನ್ನು ಎಂದು ನೀವು ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಸೇರಿಸಲು.

811
00:45:23,000 --> 00:45:30,000
ಕಾರ್ಯಗತಗೊಳಿಸಿ.

812
00:45:30,000 --> 00:45:32,000
ಸರಿ, ಉತ್ತಮ.

813
00:45:32,000 --> 00:45:38,000
ನೀವು ಸುಮಾರು ಎಡ ಕೈ ತೆರಳುತ್ತಾರೆ ಮೊದಲು ಈಗ ಎಚ್ಚರಿಕೆಯಿಂದ ಭಾವಿಸುತ್ತೇನೆ.

814
00:45:38,000 --> 00:45:46,000
ನೀವು ಬಹಳ ಇಂದು ಅತ್ಯಂತ ವಿಚಿತ್ರವಾದ ಪಾತ್ರ ದೊರೆಯಿತು.

815
00:45:46,000 --> 00:45:59,000
ಯಾರ ಕೈ ಮೊದಲ ಸ್ಥಳಾಂತರಿಸಲಾಯಿತು ಮಾಡಬೇಕು?

816
00:45:59,000 --> 00:46:02,000
ಸರಿ, ನಾನು ಯಾವುದೇ ವಿಚಾರಣೆಗೆ ನಾನು, ನಿರೀಕ್ಷಿಸಿ.

817
00:46:02,000 --> 00:46:07,000
ಕೆಲವು ಜನರಾಗಿದ್ದರು ನಯವಾಗಿ ಇಲ್ಲಿ ಒಂದು ಎಡವಟ್ಟಾದ ಪರಿಸ್ಥಿತಿಯು ಪರಿಹರಿಸಲು ಸಹಾಯ ಬಯಸಿದರೆ.

818
00:46:07,000 --> 00:46:11,000
ಅವರ ಎಡಗೈ ಮೊದಲ ಬಹುಶಃ ಅಪ್ಡೇಟ್ ಮಾಡಬೇಕು? ಹೌದು.

819
00:46:11,000 --> 00:46:13,000
[ವಿದ್ಯಾರ್ಥಿ] ಸಾದ್ ನ.

820
00:46:13,000 --> 00:46:15,000
ಸರಿ, ಸಾದ್ ನ, ಏಕೆ, ಆದರೂ?

821
00:46:15,000 --> 00:46:17,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

822
00:46:17,000 --> 00:46:19,000
ಉತ್ತಮ, ಏಕೆಂದರೆ ನಾವು ಸರಿಸಲು-ಹೀಗಾದರೆ ನಿಮ್ಮ ಹೆಸರು '? >> ಮಾರ್ಷಲ್.

823
00:46:19,000 --> 00:46:22,000
ಮಾರ್ಷಲ್, ನಾವು ಶೂನ್ಯ ಮೊದಲ ಕೆಳಗೆ ಕೈ ಸರಿಸಲು ವೇಳೆ,

824
00:46:22,000 --> 00:46:25,000
ಈಗ ನಾವು ಅಕ್ಷರಶಃ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ನಾಲ್ಕು ಜನರು ಅನಾಥ ಎಂದು

825
00:46:25,000 --> 00:46:29,000
ಅವರು, ರಾಮನ್ ಮತ್ತು ಎಡ ಎಲ್ಲರೂ ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಮಾತ್ರ ವಿಷಯ ಏಕೆಂದರೆ

826
00:46:29,000 --> 00:46:31,000
ಆದ್ದರಿಂದ ಮೊದಲ ಎಂದು ಪಾಯಿಂಟರ್ ಅಪ್ಡೇಟ್ ಕಳಪೆಯಾಗಿತ್ತು.

827
00:46:31,000 --> 00:46:33,000
ಅವರ ಆ ಮೇಲಕ್ಕೆ ಲೆಟ್.

828
00:46:33,000 --> 00:46:37,000
ಗುಡ್, ಮತ್ತು ಈಗ ಮುಂದುವರಿಯಿರಿ ಮತ್ತು ರಾಮನ್ ನಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಸೂಕ್ತ ಎಡಗೈ ಸರಿಸಲು.

829
00:46:37,000 --> 00:46:39,000
ಈ ಸ್ವಲ್ಪ ಅಧಿಕ ಭಾವಿಸುತ್ತಾನೆ.

830
00:46:39,000 --> 00:46:41,000
ಈಗ ರಾಮನ್ ನಲ್ಲಿ ತೋರಿಸುವ ಎರಡು ಜನರು, ಆದರೆ ಆ ದಂಡವನ್ನು ಇಲ್ಲಿದೆ

831
00:46:41,000 --> 00:46:43,000
ಏಕೆಂದರೆ ಈಗ ಹೇಗೆ ಬೇರೆ ನಾವು ಪಟ್ಟಿ ಅಪ್ಡೇಟ್ ಇಲ್ಲ?

832
00:46:43,000 --> 00:46:48,000
ಏನು ಮತ್ತೊಂದೆಡೆ ಸರಿಸಲು ಹೊಂದಿದೆ?

833
00:46:48,000 --> 00:46:53,000
ಉತ್ತಮ, ಈಗ ನಾವು ಯಾವುದೇ ಮೆಮೊರಿ ಲಾಸ್ಟ್?

834
00:46:53,000 --> 00:46:57,000
ಇಲ್ಲ, ಸೋ ಗುಡ್, ನಾವು ಈ ಬಾರಿ ಹೆಚ್ಚು ಮುರಿಯಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನೋಡೋಣ.

835
00:46:57,000 --> 00:47:00,000
>> , ಸಂಖ್ಯೆ 5 ಕೊನೆಯ Mallocing.

836
00:47:00,000 --> 00:47:04,000
ಮತ್ತೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ, ಕೆಳಗೆ ಮೇಲೆ ಬರುತ್ತಾರೆ.

837
00:47:04,000 --> 00:47:08,000
ಇದು ತುಂಬಾ ಉತ್ತೇಜನಕಾರಿಯಾಗಿದೆ.

838
00:47:08,000 --> 00:47:15,000
[ಚಪ್ಪಾಳೆಯನ್ನು]

839
00:47:15,000 --> 00:47:17,000
ನಿಮ್ಮ ಹೆಸರೇನು? >> ರಾನ್.

840
00:47:17,000 --> 00:47:19,000
ರಾನ್, ಸರಿ, ನೀವು ಸಂಖ್ಯೆ 5 ಎಂದು malloced ಮಾಡಲಾಗುತ್ತದೆ.

841
00:47:19,000 --> 00:47:23,000
ನಾವು ಈ ಏಕಸ್ವರೂಪದ್ದಾಗಿತ್ತು ಎಂದು ಕೋಡ್ ಶಿರಚ್ಛೇದನೆ ಮಾಡಿದ

842
00:47:23,000 --> 00:47:26,000
ಕೇವಲ ವಿವಿಧ ಹೆಸರಿನ.

843
00:47:26,000 --> 00:47:28,000
ಅತ್ಯುತ್ತಮ.

844
00:47:28,000 --> 00:47:38,000
ಈಗ, ಅನಿತಾ, ಅದೃಷ್ಟ ಈಗ ಪಟ್ಟಿಯಲ್ಲಿ ಆಗಿ ಸಂಖ್ಯೆ 5 ತೂರಿಸುವ.

845
00:47:38,000 --> 00:47:43,000
ಗುಡ್, ಮತ್ತು?

846
00:47:43,000 --> 00:47:47,000
ಅದ್ಭುತ, ಈ ನಿಜವಾಗಿಯೂ ಮೂರು ಒಟ್ಟು ಪ್ರಕರಣಗಳು ಥರ್ಡ್.

847
00:47:47,000 --> 00:47:49,000
ನಾವು ಮೊದಲ ರೆಬೆಕ್ಕಾ, ಕೊನೆಯಲ್ಲಿ ಯಾರಾದರೂ ಹೊಂದಿತ್ತು.

848
00:47:49,000 --> 00:47:51,000
ನಾವು ಆಗ ಮಧ್ಯದಲ್ಲಿ ಯಾರಾದರೂ ಹೊಂದಿತ್ತು.

849
00:47:51,000 --> 00:47:53,000
ಈಗ ನಾವು, ಆರಂಭದಲ್ಲಿ, ಈ ಉದಾಹರಣೆಯಲ್ಲಿ ಯಾರಾದರೂ ಹೊಂದಿವೆ

850
00:47:53,000 --> 00:47:56,000
ನಾವು ಈಗ ಮೊದಲ ಬಾರಿಗೆ ಲ್ಯೂಕಾಸ್ ನವೀಕರಿಸಲು ಹೊಂದಿತ್ತು

851
00:47:56,000 --> 00:48:00,000
ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ ಅಂಶ ಈಗ ಒಂದು ಹೊಸ ನೋಡ್ ಕಡೆ ಏಕೆಂದರೆ,

852
00:48:00,000 --> 00:48:03,000
ಇವರು ಅನುಕ್ರಮವಾಗಿ, ನೋಡ್ ಸಂಖ್ಯೆ 9 ನಲ್ಲಿ ತೋರಿಸುವ ಇದೆ.

853
00:48:03,000 --> 00:48:06,000
>> ಈ ಒಂದು ಅದ್ಧೂರಿ ವಿಚಿತ್ರವಾಗಿ ತೋರಿಸಲು, ನಾನು ನನಗೆ ಖಾತ್ರಿಯಿದೆ

854
00:48:06,000 --> 00:48:08,000
ಆದ್ದರಿಂದ ಈ ಹುಡುಗರಿಗೆ ಶಬ್ದಗಳಿಂದ ಕೂಡಿದ ದೊಡ್ಡ ಸುತ್ತಿನಲ್ಲಿ ನೀವು ಎಂದು.

855
00:48:08,000 --> 00:48:11,000
ಉತ್ತಮವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ.

856
00:48:11,000 --> 00:48:17,000
ಅಷ್ಟೇ. ನೀವು ಸ್ವಲ್ಪ ಮೆಮೊರಿ ಮಾಹಿತಿ ಕಾಗದದ ನಿಮ್ಮ ತುಣುಕುಗಳನ್ನು ಇಡಬಹುದು.

857
00:48:17,000 --> 00:48:22,000
ಇದು ಕೋಡ್ ಈ ಮಾಡುವುದರಿಂದ ಎಂದು ತಿರುಗುತ್ತದೆ

858
00:48:22,000 --> 00:48:26,000
ಕೇವಲ ಸುಮಾರು ಕೈಗಳ ಚಲನೆ ಸಾಕಷ್ಟು ಸರಳವಾಗಿಲ್ಲ

859
00:48:26,000 --> 00:48:28,000
ಮತ್ತು ವಿವಿಧ ಕೆಲಸಗಳನ್ನು ಪಾಯಿಂಟರ್ಸ್ ಸೂಚಿಸುವ.

860
00:48:28,000 --> 00:48:31,000
ಆದರೆ ಸ್ವಲ್ಪ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಮಯ ಬಂದಾಗ ಅರ್ಥ

861
00:48:31,000 --> 00:48:34,000
ನೀವು ನಿಜವಾಗಿಯೂ ಗಮನ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಅಥವಾ ಇದು ಒಂದು ಭಿನ್ನ

862
00:48:34,000 --> 00:48:38,000
ಈ ಮೂಲ ಮೂಲಭೂತ, ನಾನು ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಹೊಂದಿರುತ್ತವೆ ತಿಂದ ಗಾತ್ರದ ಸಮಸ್ಯೆಗಳನ್ನು,

863
00:48:38,000 --> 00:48:43,000
ಈ ಕಡೆ ಅಥವಾ ಈ ಕಡೆ ಆಗಿದೆ, ಏನು ಇಲ್ಲದಿದ್ದರೆ ಸಾಕಷ್ಟು ಸಂಕೀರ್ಣ ಕಾರ್ಯಕ್ರಮವನ್ನು ಅರ್ಥ

864
00:48:43,000 --> 00:48:47,000
ವಾಸ್ತವವಾಗಿ, ಈ ಮಾದರಿಯ ಸರಳವಾದ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್ಸ್ ಕಡಿಮೆ ಮಾಡಬಹುದು.

865
00:48:47,000 --> 00:48:51,000
>> ಇನ್ನೂ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ದಿಕ್ಕಿನಲ್ಲಿ ವಿಷಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ.

866
00:48:51,000 --> 00:48:53,000
ನಾವು ಈಗ ಲಿಂಕ್ ಪಟ್ಟಿ ಕಲ್ಪನೆ ಹೊಂದಿವೆ.

867
00:48:53,000 --> 00:48:57,000
ಮತ್ತೆ ಸಲಹೆ ಇಲ್ಲ-ಒಂದು ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿಗೆ ನಾವು ದರಿದ್ರ ಧನ್ಯವಾದಗಳು,

868
00:48:57,000 --> 00:49:01,000
ಇದು ಸುಮಾರು ಅದೇ ಕಾಣುತ್ತದೆ, ಆದರೆ ಈಗ ನಾವು struct ಒಳಗೆ ಎರಡು ಪಾಯಿಂಟರ್ಸ್ ಹೊಂದಿವೆ

869
00:49:01,000 --> 00:49:05,000
ಒಂದರ ಬದಲಾಗಿ, ನಾವು ಬಹುಶಃ ಆ ಪಾಯಿಂಟರ್ಸ್ ಹಿಂದಿನ ಮತ್ತು ಮುಂದಿನ ಕರೆಯಬಹುದು

870
00:49:05,000 --> 00:49:08,000
ಅಥವಾ ಎಡಕ್ಕೆ ಅಥವಾ ಬಲಕ್ಕೆ, ಆದರೆ, ವಾಸ್ತವವಾಗಿ, ಅವುಗಳಲ್ಲಿ ಎರಡು ಬೇಕು.

871
00:49:08,000 --> 00:49:10,000
ಕೋಡ್ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಒಳಗೊಂಡಿತ್ತು ಎಂದು.

872
00:49:10,000 --> 00:49:12,000
ಅನಿತಾ ವೇದಿಕೆಯಲ್ಲಿ ಇಲ್ಲಿ ಹೆಚ್ಚು ಕೆಲಸ ಮಾಡಲು ಹೊಂದಿತ್ತು.

873
00:49:12,000 --> 00:49:15,000
ಆದರೆ ನಾವು ಖಂಡಿತವಾಗಿಯೂ ರಚನೆ ಆ ರೀತಿಯ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಯಿತು.

874
00:49:15,000 --> 00:49:19,000
ಸಮಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಪರಿಭಾಷೆಯಲ್ಲಿ, ಆದರೂ ಯಾವ ಚಾಲನೆಯ ಸಮಯ ಎಂದು

875
00:49:19,000 --> 00:49:24,000
ಈಗ ಲಿಂಕ್ ಪಟ್ಟಿಯಲ್ಲಿ ಒಂದು ಸಂಖ್ಯೆ n ಕಂಡುಹಿಡಿಯುವ ಅನಿತಾ ಫಾರ್?

876
00:49:24,000 --> 00:49:27,000
N ಇನ್ನೂ ದೊಡ್ಡ ಒ, ಆದ್ದರಿಂದ ರೇಖೀಯ ಹುಡುಕಾಟ ಗಿಂತ ಉತ್ತಮ.

877
00:49:27,000 --> 00:49:29,000
ನಾವು ಮತ್ತೆ, ಆದರೂ, ಬೈನರಿ ಸರ್ಚ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.

878
00:49:29,000 --> 00:49:34,000
ಕೇಸ್ ಎಂದು ಏಕೆ ಎಂದು? ನೀವು ಸುಮಾರು ಜಂಪ್ ಸಾಧ್ಯವಿಲ್ಲ.

879
00:49:34,000 --> 00:49:36,000
ನಾವು ನಿಸ್ಸಂಶಯವಾಗಿ ವೇದಿಕೆಯಲ್ಲಿ ಎಲ್ಲಾ ಮಾನವರು, ನೋಡಿ ಸಹ

880
00:49:36,000 --> 00:49:39,000
ಮತ್ತು ಅನಿತಾ ", ಇಲ್ಲಿ ಪಟ್ಟಿ ಮಧ್ಯಮ" ಇದು eyeballed ಮತ್ತು ಹೇಳಿದರು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

881
00:49:39,000 --> 00:49:42,000
ಅವಳು ಕಂಪ್ಯೂಟರ್ ಪ್ರೋಗ್ರಾಂ ಆಗಿದ್ದರೆ ಅವಳು ತಿಳಿಯಲು ಅಸಾಧ್ಯ

882
00:49:42,000 --> 00:49:47,000
ಅವರು ಕೇವಲ ವಿಷಯ ಸನ್ನಿವೇಶದಲ್ಲಿ ಆರಂಭದಲ್ಲಿ ಮೇಲೆ ತಾಳ ಕಾರಣ

883
00:49:47,000 --> 00:49:50,000
ಮೊದಲ ಪಾಯಿಂಟರ್ ಯಾರು ಲ್ಯೂಕಾಸ್, ಆಗಿತ್ತು.

884
00:49:50,000 --> 00:49:53,000
ಅವರು ಅವಶ್ಯವಾಗಿ, ಆ ಕೊಂಡಿಗಳು ಅನುಸರಿಸಬೇಕಾಗುವುದು

885
00:49:53,000 --> 00:49:56,000
ಅವಳು ಸುಮಾರು ಮಧ್ಯಮ ಕಂಡುಬಂದಿಲ್ಲ ರವರೆಗೆ ತನ್ನ ರೀತಿಯಲ್ಲಿ ಎಣಿಸುವ,

886
00:49:56,000 --> 00:49:58,000
ಮತ್ತು ನಂತರ, ಆಕೆ ಮಧ್ಯಮ ತಲುಪಿದ್ದೇನೆ ಯಾವಾಗ ಹಿಂದಿರುಗಬಹುದೆಂದು

887
00:49:58,000 --> 00:50:01,000
ಆಕೆ, ಅಲ್ಲಿ ಎಷ್ಟು ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಕೊನೆಯಲ್ಲಿ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗುತ್ತದೆ ಹೊರತು

888
00:50:01,000 --> 00:50:05,000
ನೀವು ಮಾಡದೇ ನಂತರ backtracks, ಮತ್ತು ತುಂಬಾ ಹಾರ್ಡ್ ಎಂದು

889
00:50:05,000 --> 00:50:07,000
ವಿಧದ ದುಪ್ಪಟ್ಟು ಲಿಂಕ್ ಪಟ್ಟಿ.

890
00:50:07,000 --> 00:50:10,000
>> ಇಂದು ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವ, ಆದರೆ ಇತರರು ಪರಿಚಯಿಸುವ.

891
00:50:10,000 --> 00:50:12,000
ಬೇರೆ ಅಕ್ಷಾಂಶ ರಚನೆ ಒಟ್ಟಾರೆಯಾಗಿ ಬಗ್ಗೆ ಏನು?

892
00:50:12,000 --> 00:50:15,000
ಈ, ಮ್ಯಾಥರ್ ಹೌಸ್ ಟ್ರೇನಲ್ಲಿ ಒಂದು ಛಾಯಾಚಿತ್ರ

893
00:50:15,000 --> 00:50:19,000
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಕೂಡ ರೀತಿಯ ಈಗಾಗಲೇ ಬಗ್ಗೆ ಮಾಡಿರುವ ಡೇಟಾ ರಚನೆ ಹೊಂದಿವೆ.

894
00:50:19,000 --> 00:50:22,000
ನಾವು, ಮೆಮೊರಿ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು

895
00:50:22,000 --> 00:50:26,000
ಮತ್ತು ಆ ರೀತಿಯ ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಹೆಸರಿನ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ ಮೆಮೊರಿ ಪರಿಭಾಷೆಯಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್

896
00:50:26,000 --> 00:50:31,000
ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮೇಲೆ ವಿಸ್ತರಣೆಯಾದ ಹೆಚ್ಚಿನ ವಿಷಯವನ್ನು ಹೊಂದಿರುವ ಅಕ್ಷಾಂಶ ರಚನೆಯಾಗಿದೆ.

897
00:50:31,000 --> 00:50:35,000
ಆದರೆ ಸ್ಟಾಕ್ ಬಗ್ಗೆ ಆಸಕ್ತಿಕರ ವಿಷಯ, ಮಾಹಿತಿ, ವಾಸ್ತವದಲ್ಲಿ ಸಂದರ್ಭದಲ್ಲಿ

898
00:50:35,000 --> 00:50:38,000
ಇದು ಅಕ್ಷಾಂಶ ರಚನೆಯ ಒಂದು ವಿಶೇಷ ರೀತಿಯ ಎಂಬುದು.

899
00:50:38,000 --> 00:50:42,000
ಇದು ದತ್ತಾಂಶ ರಚನೆಯ ಬಗೆಗಿನ ಮೊದಲ ಅಂಶ

900
00:50:42,000 --> 00:50:46,000
ಕೊನೆಯ ಅಂಶ ಔಟ್ ಆಗಿದೆ.

901
00:50:46,000 --> 00:50:50,000
ನೀವು ಸ್ಟಾಕ್ ಮೇಲೆ ಪುಟ್ ಮೊದಲ ಟ್ರೇ ಇದ್ದರೆ

902
00:50:50,000 --> 00:50:53,000
ನೀವು, ದುರದೃಷ್ಟವಶಾತ್ ಸ್ಟಾಕ್ ತೆಗೆದುಹಾಕಬೇಕು ಕೊನೆಯ ಟ್ರೇ ಎಂದು ನೀನು

903
00:50:53,000 --> 00:50:55,000
ಮತ್ತು ಒಂದು ಒಳ್ಳೆಯ ವಿಷಯ ಎಂದೇನೂ ಅಲ್ಲ.

904
00:50:55,000 --> 00:50:58,000
ವ್ಯತಿರಿಕ್ತವಾಗಿ, ನೀವು ಇತರ ಹಾದಿ ಬಗ್ಗೆ ನಗರದ

905
00:50:58,000 --> 00:51:02,000
ಕೊನೆಯ ಮೊದಲ ಔಟ್ ಆಗಿದೆ.

906
00:51:02,000 --> 00:51:05,000
>> ಈಗ ಯಾವುದೇ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ಹೊಂದಿರುವ ಅಲ್ಲಿ ಮನಸ್ಸಿಗೆ ಬಂದರೆ

907
00:51:05,000 --> 00:51:08,000
ಆ ಆಸ್ತಿಯನ್ನು ಹೊಂದಿವೆ ಅಕ್ಷಾಂಶ ರಚನೆ

908
00:51:08,000 --> 00:51:13,000
ಮೊದಲು, ರಲ್ಲಿ ಕೊನೆಯ ವಾಸ್ತವವಾಗಿ ಬಲವಾದ ಹೊಂದಿದೆ?

909
00:51:13,000 --> 00:51:16,000
ಒಂದು ಒಳ್ಳೆಯದು? ಒಂದು ಕೆಟ್ಟ ವಿಷಯ?

910
00:51:16,000 --> 00:51:19,000
ಟ್ರೇಗಳು ಎಲ್ಲಾ ಒಂದೇ ಇಲ್ಲದಿದ್ದರೆ ಇದು ಖಂಡಿತವಾಗಿಯೂ ಒಂದು ಕೆಟ್ಟ ವಿಷಯ

911
00:51:19,000 --> 00:51:21,000
ಮತ್ತು ಅವರು, ಎಲ್ಲಾ ವಿಶೇಷ ವಿಭಿನ್ನ ಬಣ್ಣಗಳನ್ನು ಅಥವಾ ಸ್ಪಷ್ಟವಾಗಿ ವಿವರಿಸಲಾಗದ ಯಾ ಕೆಲಸಕ್ಕೆ ಬಾರದ ವಸ್ತು ಎಂದು

912
00:51:21,000 --> 00:51:24,000
ಮತ್ತು ನೀವು ಬಯಸುವ ಬಣ್ಣವನ್ನು ಕೆಳಭಾಗದಲ್ಲಿ ಎಲ್ಲಾ ಮಾರ್ಗವಾಗಿದೆ.

913
00:51:24,000 --> 00:51:26,000
ಸಹಜವಾಗಿ, ನೀವು ಮಹಾನ್ ಪ್ರಯತ್ನಗಳನ್ನು ಇಲ್ಲದೆ ಎಂದು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ.

914
00:51:26,000 --> 00:51:28,000
ನೀವು ಮೇಲಿನಿಂದ ಪ್ರಾರಂಭಿಸಿ ಮತ್ತು ನಿಮ್ಮ ದಾರಿ ಕೆಳಗೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

915
00:51:28,000 --> 00:51:31,000
ಹಾಗೆಯೇ, ನೀವು ಈ ಅಭಿಮಾನಿ ಹುಡುಗರು ಒಂದಾಗಿದೆ ಹೀಗಾದರೆ

916
00:51:31,000 --> 00:51:34,000
ಯಾರು ಅಪ್ ಒಂದು ಐಫೋನ್ ಮತ್ತು ಸಾಲುಗಳನ್ನು ಪಡೆಯಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಎಲ್ಲಾ ರಾತ್ರಿ ಅಪ್ ಕಾಯುತ್ತದೆ

917
00:51:34,000 --> 00:51:36,000
ಇಂತಹ ಒಂದು ಸ್ಥಳದಲ್ಲಿ?

918
00:51:36,000 --> 00:51:40,000
ಇದು ಉತ್ತಮ ಅಲ್ಲ ಎಂದು ಆಪಲ್ ಸ್ಟೋರ್

919
00:51:40,000 --> 00:51:42,000
ಒಂದು ಸ್ಟಾಕ್ ಅಕ್ಷಾಂಶ ರಚನೆ ಎಂದು?

920
00:51:42,000 --> 00:51:44,000
ವಾಹ್? ಒಪ್ಪುವುದಿಲ್ಲ?

921
00:51:44,000 --> 00:51:47,000
ಕಳೆದ ಸಾಧ್ಯ ಗಳಿಗೆಯಲ್ಲಿ ತೋರಿಸುತ್ತವೆ ಜನರಿಗೆ ಮಾತ್ರ ಒಳ್ಳೆಯದು

922
00:51:47,000 --> 00:51:50,000
ತದನಂತರ ಕ್ಯೂ ಆಫ್ ಪ್ಲಕ್ಡ್ ಪಡೆಯುತ್ತೀರಿ.

923
00:51:50,000 --> 00:51:52,000
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಾನು ಒಲವು ಎಂದು ವಾಸ್ತವವಾಗಿ ಕ್ಯೂ ಹೇಳಲು

924
00:51:52,000 --> 00:51:56,000
, ಈ ರೀತಿಯ ಮಾಹಿತಿ ರಚನೆಯ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಜೊತೆಗೆ ವಾಸ್ತವವಾಗಿ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ

925
00:51:56,000 --> 00:51:59,000
ಆದೇಶವನ್ನು ವಿಷಯವಾಗಿದೆ ಅಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಒಂದು,

926
00:51:59,000 --> 00:52:02,000
ಮತ್ತು ನೀವು ಮೊದಲ ಒಂದು ಮೊದಲ ಒಂದು ಔಟ್ ಎಂದು ಬಯಸುವ

927
00:52:02,000 --> 00:52:04,000
ಮಾನವ ಫೇರ್ನೆಸ್ ಸಲುವಾಗಿ ಮಾತ್ರ.

928
00:52:04,000 --> 00:52:07,000
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಕ್ಯೂ ಅಕ್ಷಾಂಶ ರಚನೆ ಎಂದು ಕರೆ ಮಾಡುತ್ತೇವೆ.

929
00:52:07,000 --> 00:52:11,000
>> ಲಿಂಕ್ಡ್ ಇಟ್ ಪಟ್ಟಿಗಳನ್ನು ಜೊತೆಗೆ, ಈ ಅದೇ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆರಂಭಿಸಬಹುದು ತಿರುಗಿದರೆ

930
00:52:11,000 --> 00:52:15,000
ಮತ್ತು ಸಮಸ್ಯೆಗಳಿಗೆ ಪರಿಹಾರಗಳನ್ನು ಹೊಸ ಮತ್ತು ವಿವಿಧ ರಚಿಸುವುದನ್ನು ಪ್ರಾರಂಭಿಸುವ.

931
00:52:15,000 --> 00:52:19,000
ಉದಾಹರಣೆಗೆ, ಒಂದು ಸ್ಟಾಕ್ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಸ್ಟಾಕ್ ಬಿಂಬಿಸುತ್ತದೆ

932
00:52:19,000 --> 00:52:22,000
ಈ ರೀತಿಯ ಒಂದು ಅಕ್ಷಾಂಶ ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನಾನು ಸಲಹೆ ಎಂದು.

933
00:52:22,000 --> 00:52:26,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು struct ಡಿಕ್ಲೇರ್ಡ್ ನಾನೀಗ ಈ ರಚನೆಯ ಒಳಗೆ ಹೇಳುತ್ತಿದ್ದೆ

934
00:52:26,000 --> 00:52:30,000
ಸಂಖ್ಯೆಗಳನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮತ್ತು ನಂತರ ವೇರಿಯಬಲ್ ಎಂಬ ಗಾತ್ರ, ಆಗಿದೆ

935
00:52:30,000 --> 00:52:33,000
ಮತ್ತು ನಾನು ಈ ವಿಷಯದಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ಕರೆಯಲು ಹೋಗುತ್ತಿದ್ದೇನೆ.

936
00:52:33,000 --> 00:52:35,000
ಈಗ, ಈ ವಾಸ್ತವವಾಗಿ ಕೆಲಸ ಇಲ್ಲ ಏಕೆ?

937
00:52:35,000 --> 00:52:43,000
ಒಂದು ಸ್ಟಾಕ್ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪರದೆಯ ಮೇಲೆ ಈ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬರೆಯಬಲ್ಲ.

938
00:52:43,000 --> 00:52:47,000
ಇಲ್ಲಿ ನನ್ನ ರಾಶಿಯಿದೆ. ಆ ನನ್ನ ಸಂಖ್ಯೆಗಳು.

939
00:52:47,000 --> 00:52:50,000
ಮತ್ತು ನಾವು, ಈ, ಈ, ಈ ಈ ಈ ಅವರನ್ನು ಸೆಳೆಯಲು ಮಾಡುತ್ತೇವೆ.

940
00:52:50,000 --> 00:52:53,000
ಆಗ ನಾನು, ಇಲ್ಲಿ ಕೆಲವು ಡೇಟಾವನ್ನು ಸದಸ್ಯ ಹೊಂದಿವೆ

941
00:52:53,000 --> 00:52:58,000
ಗಾತ್ರ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಹಾಗಾಗಿ, ಈ ಗಾತ್ರ, ಮತ್ತು ಈ ಸಂಖ್ಯೆಗಳನ್ನು

942
00:52:58,000 --> 00:53:02,000
ಮತ್ತು ಒಟ್ಟಾರೆಯಾಗಿ, ಇಲ್ಲಿ ಇಡೀ ಐಪ್ಯಾಡ್ ಒಂದು ಸ್ಟಾಕ್ ರಚನೆ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

943
00:53:02,000 --> 00:53:07,000
ಈಗ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಗಾತ್ರ ಸಂಭಾವ್ಯವಾಗಿ, 0 ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಎಂದು ದೊರೆತಿದೆ

944
00:53:07,000 --> 00:53:11,000
ಮತ್ತು ಆರಂಭದಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ರಚನೆಯ ಒಳಗೆ ಇಲ್ಲಿದೆ

945
00:53:11,000 --> 00:53:14,000
ನಾನು ಮೊದಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಿಯೋಜಿಸಿ ಯಾವಾಗ?

946
00:53:14,000 --> 00:53:16,000
ಕಸದ. ಹೂ ನೋಸ್? ಮತ್ತು ಇದು ವಾಸ್ತವವಾಗಿ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

947
00:53:16,000 --> 00:53:20,000
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಯಾದೃಚ್ಛಿಕವಾಗಿ, ಈ 1, 2, 3, 4, 5 ವೇಳೆ ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ

948
00:53:20,000 --> 00:53:25,000
ನನ್ನ ರಚನೆ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ದುರದೃಷ್ಟವಶಾತ್ ಅದಕ್ಕೆ ಬಹಳ ನಾನು ತಿಳಿದಿರುವಂತೆ ಏಕೆಂದರೆ ಸ್ಟಾಕ್ ಗಾತ್ರವನ್ನು

949
00:53:25,000 --> 00:53:29,000
0, ನಂತರ ನಾನು ಸರಣಿಬದ್ಧವಾಗಿ ತಿಳಿದಿರುವ, ರಚನೆಯ ಅಂಶಗಳ ಯಾವುದೇ ನೋಡಲು ಇಲ್ಲ.

950
00:53:29,000 --> 00:53:31,000
ಇದು ಇಲ್ಲ ಎಂಬುದನ್ನು ಲೆಕ್ಕಕ್ಕೆ ಬರುವುದಿಲ್ಲ.

951
00:53:31,000 --> 00:53:34,000
0 ಒಂದು ಗಾತ್ರ ಪರಿಣಾಮ ಎಂದು ಮಾಹಿತಿ, ಅವುಗಳನ್ನು ನೋಡಲು ಇಲ್ಲ.

952
00:53:34,000 --> 00:53:38,000
>> ಆದರೆ ನಾನು ಮುಂದೆ ಹೋಗಿ ಸ್ಟ್ಯಾಕ್ನಲ್ಲಿ ಏನೋ ಸೇರಿಸಲು ಈಗ ಊಹಿಸಿಕೊಳ್ಳಿ.

953
00:53:38,000 --> 00:53:42,000
ನಾನು ಸಂಖ್ಯೆ 5 ಸೇರಿಸಲು ಬಯಸುವ, ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲಿ ಸಂಖ್ಯೆ 5 ಪುಟ್

954
00:53:42,000 --> 00:53:45,000
ಮತ್ತು ನಂತರ ನಾನು ಇಲ್ಲಿ ಯಾವ ಪತನವಾದರೆ ಇಲ್ಲ?

955
00:53:45,000 --> 00:53:48,000
ಈಗ ನಾನು ವಾಸ್ತವವಾಗಿ ಗಾತ್ರ 1 ಪತನವಾದರೆ ಎಂದು

956
00:53:48,000 --> 00:53:50,000
ಮತ್ತು ಈಗ ಸ್ಟಾಕ್ ಗಾತ್ರ 1 ಹೊಂದಿದೆ.

957
00:53:50,000 --> 00:53:53,000
ನಾನು ಮುಂದೆ ಹೋಗಿ ಸಂಖ್ಯೆ ಸೇರಿಸಲು ವೇಳೆ, ಏನು ಈಗ 7 ಮುಂದಿನ, ಹೇಳಿ?

958
00:53:53,000 --> 00:53:57,000
ಈ ನಂತರ 2 ಅಪ್ಡೇಟ್ ಮಾಡಲ್ಪಡುತ್ತವೆ, ಮತ್ತು ನಾವು, 9 ಮಾಡುತ್ತೇನೆ

959
00:53:57,000 --> 00:54:02,000
ತದನಂತರ ಈ 3 ಅಪ್ಡೇಟ್ ಮಾಡಲ್ಪಡುತ್ತವೆ.

960
00:54:02,000 --> 00:54:05,000
ಆದರೆ ಈ ಸ್ಟಾಕ್ ಈಗ ಆಸಕ್ತಿದಾಯಕ ಲಕ್ಷಣವೆಂದರೆ

961
00:54:05,000 --> 00:54:09,000
ನಾನು ಪಾಪ್ ಬಯಸಿದರೆ ಇದು ಅಂಶ ತೆಗೆದುಹಾಕಲು ಭಾವಿಸಲಾದ ನಾನು

962
00:54:09,000 --> 00:54:12,000
ಸ್ಟಾಕ್ ನ ಏನೋ ಆಫ್, ಆದ್ದರಿಂದ ಮಾತನಾಡಲು?

963
00:54:12,000 --> 00:54:14,000
9 ಹೋಗಲು ಮೊದಲ ವಿಷಯ ಎಂದು.

964
00:54:14,000 --> 00:54:18,000
ನಾನು ಸ್ಟಾಕ್ ಆಫ್ ಒಂದು ಅಂಶ ಪಾಪ್ ಬಯಸಿದರೆ ಹೇಗೆ ಚಿತ್ರ, ಬದಲಿಸಬೇಕಾಗುತ್ತದೆ

965
00:54:18,000 --> 00:54:20,000
ಹೆಚ್ಚು ಮ್ಯಾಥರ್ ಒಂದು ಟ್ರೇ ಇಷ್ಟ?

966
00:54:20,000 --> 00:54:22,000
ಹೌದು. 2 >> [ವಿದ್ಯಾರ್ಥಿ] ಸೆಟ್ ಗಾತ್ರ.

967
00:54:22,000 --> 00:54:27,000
ನಿಖರವಾಗಿ, ನಾನು ಎಲ್ಲ 2 ಗಾತ್ರದಲ್ಲಿ ಸೆಟ್ ಇದೆ, ಮತ್ತು ನಾನು ಸಹಿತ ಏನು ಮಾಡಬೇಕು?

968
00:54:27,000 --> 00:54:29,000
ನಾನು ಏನು ಇಲ್ಲ.

969
00:54:29,000 --> 00:54:32,000
ನಾನು ಗುದ ಎಂದು, ಇಲ್ಲಿ 0 ಅಥವಾ -1 ಅಥವಾ ಸೂಚಿಸುವುದಕ್ಕಾಗಿ ಏನೋ ಪುಟ್ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

970
00:54:32,000 --> 00:54:34,000
ಇದು ಅಸಲಿ ಮೌಲ್ಯವಲ್ಲ, ಆದರೆ ಪರವಾಗಿಲ್ಲ ಎಂಬುದನ್ನು ಕಾರಣ

971
00:54:34,000 --> 00:54:37,000
ನಾನು ಎಷ್ಟು ದೀರ್ಘ ಶ್ರೇಣಿಯನ್ನು ದಾಟಿ ರೆಕಾರ್ಡ್ ಮಾಡಬಹುದು

972
00:54:37,000 --> 00:54:41,000
ಆದ್ದರಿಂದ ನಾನು ತಿಳಿದಿರುವ ಏಕೈಕ ಈ ರಚನೆಯ ಮೊದಲ ಎರಡು ಅಂಶಗಳನ್ನು ನೋಡೋಣ.

973
00:54:41,000 --> 00:54:47,000
ಈಗ, ನಾನು ಹೋಗಿ ಈ ಶ್ರೇಣಿಯನ್ನು ಸಂಖ್ಯೆ 8 ಸೇರಿಸಲು ವೇಳೆ, ಹೇಗೆ ಚಿತ್ರ ಮುಂದಿನ ಬದಲಾವಣೆ ಇಲ್ಲ?

974
00:54:47,000 --> 00:54:50,000
ಈ 8 ಆಗುತ್ತದೆ, ಮತ್ತು ಈ 3 ಆಗುತ್ತದೆ.

975
00:54:50,000 --> 00:54:52,000
ನಾನು ಇಲ್ಲಿ ಕೆಲವು ಮೂಲೆಗಳಲ್ಲಿ ಕತ್ತರಿಸುವ ನುಡಿದರು.

976
00:54:52,000 --> 00:54:56,000
ಈಗ ನಾವು 5, 7, 8, ಮತ್ತು ನಾವು ಮತ್ತೆ 3 ಒಂದು ಗಾತ್ರಕ್ಕೆ ಆರ್.

977
00:54:56,000 --> 00:54:58,000
ಇದು ಅನುಷ್ಠಾನಕ್ಕೆ ಸಾಕಷ್ಟು ಸರಳ

978
00:54:58,000 --> 00:55:06,000
ಆದರೆ ನಾವು ಈ ವಿನ್ಯಾಸದ ತೀರ್ಮಾನಕ್ಕೆ ವಿಷಾದ ಹೋಗುವ?

979
00:55:06,000 --> 00:55:09,000
ಆಗ ವಸ್ತುಗಳ ತುಂಬಾ ತಪ್ಪು ಹೋಗಲು ಆರಂಭಿಸಲು ಇಲ್ಲ? ಹೌದು.

980
00:55:09,000 --> 00:55:11,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

981
00:55:11,000 --> 00:55:13,000
ನೀವು ಹಿಂದಕ್ಕೆ ಹೋಗಿ ಮತ್ತು ನೀವು ಪುಟ್ ಮೊದಲ ಅಂಶ ಪಡೆಯಲು ಬಯಸಿದಾಗ

982
00:55:13,000 --> 00:55:18,000
>> ಒಂದು ಸ್ಟಾಕ್ HOOD ಕೆಳಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಕೂಡ ಇದು, ಇಲ್ಲಿ ತಿರುಗಿದರೆ

983
00:55:18,000 --> 00:55:21,000
ನಾವು ಬಗ್ಗೆ ಪ್ರಾರಂಭಿಸಿದಾಗ ಈ ಡೇಟಾವನ್ನು ರಚನೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಕರೆಯಲಾಗುತ್ತದೆ

984
00:55:21,000 --> 00:55:25,000
ಅಮೂರ್ತ ಅಕ್ಷಾಂಶ ರಚನೆಗಳು ಇದರಡಿ ಅವರು ಜಾರಿಗೆ ನೀವು ಹೇಗೆ

985
00:55:25,000 --> 00:55:27,000
ಸಂಪೂರ್ಣವಾಗಿ ಪಾಯಿಂಟ್ ಜೊತೆಗೆ ಆಗಿದೆ.

986
00:55:27,000 --> 00:55:31,000
ಒಂದು ಸ್ಟಾಕ್ ರೀತಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ರಚನೆ ಬೆಂಬಲವನ್ನು ಹೇಳಲಾಗುವ

987
00:55:31,000 --> 00:55:35,000
ಸ್ಟಾಕ್ ಮೇಲೆ ಟ್ರೇ ತಳ್ಳುತ್ತದೆ ಇದು ಪುಷ್ ನಂತಹ ಕಾರ್ಯಾಚರಣೆಗಳು,

988
00:55:35,000 --> 00:55:39,000
ಮತ್ತು ಸ್ಟಾಕ್ ಒಂದು ಅಂಶ ತೆಗೆದುಹಾಕುತ್ತದೆ, ಮತ್ತು ಅಷ್ಟೇ ಇದು ಪಾಪ್,.

989
00:55:39,000 --> 00:55:43,000
ನೀವು ಈಗಾಗಲೇ ಜಾರಿಗೆ ಇವರು ಬೇರೆಯವರ ಕೋಡ್ ಡೌನ್ಲೋಡ್ ಮಾಡಲು ಬಂದಾಗ

990
00:55:43,000 --> 00:55:46,000
ಈ ವಿಷಯದಲ್ಲಿ ಒಂದು ಸ್ಟಾಕ್ ಎಂದು, ಆ ವ್ಯಕ್ತಿ ಬರೆದ ಎಂದು

991
00:55:46,000 --> 00:55:49,000
ನೀವು ಕೇವಲ ಎರಡು ಕಾರ್ಯಗಳನ್ನು ತಳ್ಳಲು ಮತ್ತು ಅವರ ಏಕೈಕ ಉದ್ದೇಶ ಜೀವನದಲ್ಲಿ ಪಾಪ್,

992
00:55:49,000 --> 00:55:51,000
ನಿಖರವಾಗಿ ಮಾಡಲು ಎಂದು.

993
00:55:51,000 --> 00:55:54,000
ನೀವು ಅಥವಾ ಅವರಿಗೆ ಕಾರ್ಯಕ್ರಮವನ್ನು ಜಾರಿಗೆ ಯಾರು

994
00:55:54,000 --> 00:55:58,000
ಅನುಷ್ಠಾನಕ್ಕೆ ಹೇಗೆ ನಿರ್ಧರಿಸಲು ಸಂಪೂರ್ಣವಾಗಿ ಒಂದು ಸಾಧ್ಯತೆ

995
00:55:58,000 --> 00:56:00,000
HOOD ಕೆಳಗೆ ತಳ್ಳುತ್ತದೆ ಮತ್ತು ಪಾಪಿಂಗ್ ಶಬ್ದಾರ್ಥ

996
00:56:00,000 --> 00:56:03,000
ಅಥವಾ ತಳ್ಳುವುದು ಮತ್ತು ಪಾಪಿಂಗ್ ಕಾರ್ಯತ್ಮಕತೆಯನ್ನು.

997
00:56:03,000 --> 00:56:07,000
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಸ್ವಲ್ಪ shortsighted ನಿರ್ಧಾರ ಮಾಡಿದ

998
00:56:07,000 --> 00:56:10,000
ಈ ಸರಳ ಅಕ್ಷಾಂಶ ರಚನೆ ಏಕೆ ನನ್ನ ಸ್ಟಾಕ್ ಮಾಡುವುದೇ?

999
00:56:10,000 --> 00:56:12,000
ಈ ಡೇಟಾವನ್ನು ರಚನೆ ಬ್ರೇಕ್ ಮಾಡುತ್ತದೆ?

1000
00:56:12,000 --> 00:56:18,000
ಯಾವ ಹಂತದಲ್ಲಿ ನಾನು ಬಳಕೆದಾರ ಪುಶ್ ಕರೆ ಮಾಡಿದಾಗ ಉದಾಹರಣೆಗೆ, ಒಂದು ದೋಷ ಮರಳಲು ಹೊಂದಿಲ್ಲ?

1001
00:56:18,000 --> 00:56:20,000
[ವಿದ್ಯಾರ್ಥಿ] ಸ್ಥಳವಿಲ್ಲ ಸಾಕಷ್ಟಿರುತ್ತದೆ.

1002
00:56:20,000 --> 00:56:23,000
ನಿಖರವಾಗಿ, ಯಾವುದೇ ಸ್ಥಳವನ್ನು ನಾನು ಸಾಮರ್ಥ್ಯವನ್ನು ಮೀರಿದ್ದೇವೆ ವೇಳೆ, ವೇಳೆ ಇಲ್ಲ

1003
00:56:23,000 --> 00:56:27,000
ಇದು ಜಾಗತಿಕ ಸ್ಥಿರ ರೀತಿಯ ಎಂದು ಸೂಚಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಅದು ಎಲ್ಲಾ ಕ್ಯಾಪ್ಸ್ ಹೊಂದಿದೆ.

1004
00:56:27,000 --> 00:56:30,000
ಅಲ್ಲದೆ, ನಂತರ ನಾನು ಕ್ಷಮಿಸಿ, ನಾನು ಮತ್ತೊಂದು ಮೌಲ್ಯವನ್ನು ತಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ ", ಹೇಳಬೇಕೆಂದು ಪಡೆಯಲಿದ್ದೇನೆ

1005
00:56:30,000 --> 00:56:32,000
ಸ್ಟಾಕ್ ಮೇಲೆ, "ಹೆಚ್ಚು ಮ್ಯಾಥರ್ ರೀತಿಯಲ್ಲಿರುತ್ತದೆ.

1006
00:56:32,000 --> 00:56:36,000
>> ಒಂದು ಹಂತದಲ್ಲಿ, ಅವರು ಕಡಿಮೆ ಕ್ಯಾಬಿನೆಟ್ ಮೇಲಿನ ಭಾಗ ಹೊಡೆಯಲು ನೀನು.

1007
00:56:36,000 --> 00:56:39,000
ಸ್ಟಾಕ್ ಸ್ಥಳವಿಲ್ಲ ಅಥವಾ ಸಾಮರ್ಥ್ಯವನ್ನು ದೋಷ ರೀತಿಯ ಇಲ್ಲ ಯಾವ, ಇಲ್ಲ.

1008
00:56:39,000 --> 00:56:42,000
ಅವರು, ಟ್ರೇ ಎಲ್ಲೋ ಬೇರೆ, ಬೇರೆ ಎಲ್ಲಾದರೂ ಅಂಶ ಹಾಕಬೇಕು

1009
00:56:42,000 --> 00:56:44,000
ಅಥವಾ ಎಲ್ಲಿಯೂ ಇಲ್ಲ.

1010
00:56:44,000 --> 00:56:47,000
ಈಗ, ಒಂದು ಕ್ಯೂ ಜೊತೆಗೆ, ನಾವು ಬೇರೆ ಸ್ವಲ್ಪ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಾಯಿತು.

1011
00:56:47,000 --> 00:56:50,000
ಎ ಕ್ಯೂ HOOD ಕೆಳಗೆ, ಇದನ್ನು ಮಾಡಬಹುದು ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ

1012
00:56:50,000 --> 00:56:54,000
ಒಂದು ಸರಣಿ ಎಂದು, ಆದರೆ ಏಕೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಪ್ರಸ್ತಾಪಿಸಿ ನಾನು

1013
00:56:54,000 --> 00:56:59,000
ಸಹ ಪಟ್ಟಿಯಲ್ಲಿ ತಲೆ ಪ್ರತಿನಿಧಿಸುವ ತಲೆ ಅಂಶ ಹೊಂದಿರುತ್ತದೆ,

1014
00:56:59,000 --> 00:57:06,000
ಗಾತ್ರ ಜೊತೆಗೆ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಂದೆ, ಆಪಲ್ ಅಂಗಡಿಯಲ್ಲಿ ಸಾಲಿನ ಮೊದಲ ವ್ಯಕ್ತಿ?

1015
00:57:06,000 --> 00:57:14,000
ನಾನು ಇಲ್ಲಿ ಅಕ್ಷಾಂಶ ಹೆಚ್ಚುವರಿ ತುಂಡು ಬೇಕು?

1016
00:57:14,000 --> 00:57:16,000
ಯಾವ ಸಂಖ್ಯೆಗಳು ಮತ್ತೆ ಥಿಂಕ್

1017
00:57:16,000 --> 00:57:18,000
ನಾನು ಡ್ರಾ ನೀವು ಇದು ಅನುಸರಿಸುತ್ತದೆ.

1018
00:57:18,000 --> 00:57:21,000
, ಈಗ ಬದಲಿಗೆ ಸ್ಟಾಕ್ ಒಂದು ಕ್ಯೂ ಆಗಿದ್ದರೆ

1019
00:57:21,000 --> 00:57:24,000
ಬೀಯಿಂಗ್ ಕೇವಲ ಆಪಲ್ ಸ್ಟೋರ್-ಕ್ಯೂ ರೀತಿಯ ವ್ಯತ್ಯಾಸವನ್ನು ನ್ಯಾಯ.

1020
00:57:24,000 --> 00:57:27,000
ಪಟ್ಟಿಯ ಆರಂಭದಲ್ಲಿ ಸಾಲಿನ ಮೊದಲ ವ್ಯಕ್ತಿ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಖ್ಯೆ 5,

1021
00:57:27,000 --> 00:57:30,000
ಅವನು ಅಥವಾ ಅವಳು ಮೊದಲ ಮಳಿಗೆಗೆ ಅವಕಾಶ ಏರಲಿದೆ.

1022
00:57:30,000 --> 00:57:32,000
ನ ಹಾಗೆ ಬಿಡಿ.

1023
00:57:32,000 --> 00:57:35,000
ಈ ಆಪಲ್ ಸ್ಟೋರ್ ಈಗ ಸಮಯದಲ್ಲಿ ಈ ಕ್ಷಣದಲ್ಲಿ ನನ್ನ ಕ್ಯೂ ಸ್ಥಿತಿ, ಮತ್ತು ಆ ಪಕ್ಷ

1024
00:57:35,000 --> 00:57:39,000
ತೆರೆಯುತ್ತದೆ ಮತ್ತು ಮೊದಲ ವ್ಯಕ್ತಿ, ಸಂಖ್ಯೆ 5, ಮಳಿಗೆಗೆ ಕಾರಣವಾಯಿತು ಇದೆ.

1025
00:57:39,000 --> 00:57:43,000
ಹೇಗೆ ನಾನು ಮೊದಲ ವ್ಯಕ್ತಿ ನಿರುತ್ಪಾದಿತವಾಯಿತು ಸರದಿಯಾಗಿರಿಸಿದ ಎಂದು ಈಗ ಚಿತ್ರವನ್ನು ಬದಲಾಯಿಸಲು ಇಲ್ಲ

1026
00:57:43,000 --> 00:57:47,000
ಸಾಲಿನ ಮುಂದೆ?

1027
00:57:47,000 --> 00:57:50,000
ಅದು ಏನು? >> [ವಿದ್ಯಾರ್ಥಿ] ಕ್ಯೂ ಬದಲಾಯಿಸಿ.

1028
00:57:50,000 --> 00:57:52,000
ತಲೆ ಬದಲಾಯಿಸಬಹುದು, ಆದ್ದರಿಂದ 5 ಕಣ್ಮರೆಯಾಗುತ್ತದೆ.

1029
00:57:52,000 --> 00:57:56,000
ವಾಸ್ತವವಾಗಿ, ಈ ಮಾಡಲು ಎಂದು ಆದರೂ ಹೇಗೆ ಉತ್ತಮವಾಗಿ?

1030
00:57:56,000 --> 00:58:00,000
ಈ ವ್ಯಕ್ತಿ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ ಆದರೂ ವಾಸ್ತವದಲ್ಲಿ, ಅದು.

1031
00:58:00,000 --> 00:58:03,000
ಸಂಖ್ಯೆ 7 ನಿಜವಾದ ಅಂಗಡಿಯಲ್ಲಿ ಏನು?

1032
00:58:03,000 --> 00:58:05,000
ಅವರು ಮುಂದೆ ದೊಡ್ಡ ಹೆಜ್ಜೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

1033
00:58:05,000 --> 00:58:08,000
>> ಇದು ಸರಣಿಗಳ ಬಂದಾಗ ಆದರೆ ನಾವು ಪ್ರಶಂಸಿಸುತ್ತೇವೆ ಬಂದಿದ್ದೇನೆ

1034
00:58:08,000 --> 00:58:10,000
ಮತ್ತು ಸುಮಾರು ವಿಷಯಗಳನ್ನು ಚಲಿಸುವ?

1035
00:58:10,000 --> 00:58:12,000
ಅದು ಸರಿ, ನಿಮ್ಮ ಸಮಯ ವ್ಯರ್ಥ ಭಾಸವಾಗುತ್ತದೆ?

1036
00:58:12,000 --> 00:58:16,000
ಮೊದಲ ವ್ಯಕ್ತಿ ಹೊಂದಿರುವ ಎಂದು ಏಕೆ ನೀವು ಗುದ ಎಂದು ಹೊಂದಿಲ್ಲ

1037
00:58:16,000 --> 00:58:21,000
ಮೆಮೊರಿ ಚಂಕ್ ಆಫ್ ದೈಹಿಕವಾಗಿ ಆರಂಭದಲ್ಲಿ ಸಾಲಿನ ಆರಂಭದಲ್ಲಿ?

1038
00:58:21,000 --> 00:58:23,000
ಎಂದು ಸಂಪೂರ್ಣವಾಗಿ ಅನಗತ್ಯ ಇಲ್ಲಿದೆ. ಏಕೆ?

1039
00:58:23,000 --> 00:58:26,000
ನಾನು ಬದಲಿಗೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ ಎಂದು? >> [ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

1040
00:58:26,000 --> 00:58:30,000
ನಿಖರವಾಗಿ, ನಾನು ಈ ಹೆಚ್ಚುವರಿ ಡೇಟಾವನ್ನು ಸದಸ್ಯ ತಲೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

1041
00:58:30,000 --> 00:58:34,000
ಈಗ ಪಟ್ಟಿಯಲ್ಲಿ ಮುಖ್ಯಸ್ಥ ಇದು ಕೊಂಚ ಹಿಂದೆ ಇದು, ಇನ್ನು ಮುಂದೆ 0 ಎಂದು.

1042
00:58:34,000 --> 00:58:39,000
ಈಗ ಇದು ವಾಸ್ತವವಾಗಿ ಸಂಖ್ಯೆ 1. ಈ ರೀತಿಯಲ್ಲಿ, ನಾನು ಸ್ವಲ್ಪ ಆಪ್ಟಿಮೈಜೇಷನ್ ಪಡೆಯಿರಿ.

1043
00:58:39,000 --> 00:58:44,000
ನಾನು ಆಪಲ್ ಅಂಗಡಿಯಲ್ಲಿ ಸಾಲಿನ ಆರಂಭದಲ್ಲಿ ಸಾಲಿನಿಂದ ಯಾರಾದರೂ ನಿರುತ್ಪಾದಿತವಾಯಿತು ಸರದಿಯಾಗಿರಿಸಿದ ನೀವು ಕೇವಲ

1044
00:58:44,000 --> 00:58:47,000
ಎಲ್ಲರೂ ಒಂದು ರೇಖೀಯ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಇದು ರಿಕಾಲ್, ಬದಲಾಗುವ ಹೊಂದಿದೆ ಎಂದಲ್ಲ.

1045
00:58:47,000 --> 00:58:50,000
ನಾನು ಬದಲಿಗೆ ನಿರಂತರ ಸಮಯ ಮಾತ್ರ ಖರ್ಚು ಮಾಡಬಹುದು

1046
00:58:50,000 --> 00:58:53,000
ಮತ್ತು ನಂತರ ಒಂದು ಹೆಚ್ಚಿನ ವೇಗದ ಪ್ರತಿಕ್ರಿಯೆ ಸಾಧಿಸಲು.

1047
00:58:53,000 --> 00:58:56,000
ಆದರೆ ನಾನು ಪಾವತಿ ಭಾವಿಸುತ್ತೇನೆ ಬೆಲೆ ಹೆಚ್ಚುವರಿ ಪ್ರದರ್ಶನ ಪಡೆಯಲು ಏನು

1048
00:58:56,000 --> 00:58:58,000
ಪ್ರತಿಯೊಬ್ಬರೂ ಬದಲಾಯಿಸುವಂತೆ ಇಲ್ಲದಿರುವ?

1049
00:58:58,000 --> 00:59:01,000
ಹೌದು. >> [ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ]

1050
00:59:01,000 --> 00:59:04,000
ಹೆಚ್ಚು ಜನರನ್ನು ಸೇರಿಸಬಹುದು, ಅದು ಸಮಸ್ಯೆಯನ್ನು ಆರ್ಥೋಗೋನಲ್ಆಗಿ ಆಗಿದೆ

1051
00:59:04,000 --> 00:59:07,000
ನಾವು ಜನರನ್ನು ಸ್ಥಳಾಂತರ ಇಲ್ಲ ಇದಕ್ಕೆ.

1052
00:59:07,000 --> 00:59:11,000
ನಾವು ಎಲ್ಲರೂ ರಜೆ ಅಥವಾ-ಇಲ್ಲವೋ ಎಂಬುದನ್ನು ಆದ್ದರಿಂದ, ಇನ್ನೂ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನ

1053
00:59:11,000 --> 00:59:13,000
ಓಹ್, ನಾನು ಸರಿ, ನೀವು ಅರ್ಥವನ್ನು ನೋಡಿ.

1054
00:59:13,000 --> 00:59:16,000
ವಾಸ್ತವವಾಗಿ, ನಾನು ನೀವು ಬಹುಪಾಲು ಎಂದು ರಲ್ಲಿ ಹೇಳಿದರು ಏನನ್ನು ಒಪ್ಪುತ್ತೇನೆ

1055
00:59:16,000 --> 00:59:19,000
ನಾವು ಈಗ ಇನ್ನು ಮುಂದೆ ಈ ರಚನೆಯ ಆರಂಭ ಬಳಸಲು ಹೋಗುವ ಎಂದಿಗೂ ನೀವು

1056
00:59:19,000 --> 00:59:22,000
ನಾನು 5 ತೆಗೆದುಹಾಕಿದರೆ ಏಕೆಂದರೆ, ಆಗ ನಾನು 7 ತೆಗೆದುಹಾಕಿ.

1057
00:59:22,000 --> 00:59:24,000
ಆದರೆ ನಾನು ಮಾತ್ರ ಬಲ ಜನರನ್ನು ಪುಟ್.

1058
00:59:24,000 --> 00:59:28,000
>> ನಾನು ಜಾಗವನ್ನು ಹಾಳುಮಾಡುತ್ತಿದೆ ನಾನು ಎಂದು ಭಾವಿಸುತ್ತಾನೆ, ಮತ್ತು ಅಂತಿಮವಾಗಿ ನನ್ನ ಸರತಿ ಎಲ್ಲ ಏನೂ ಆಗಿ ವಿಭಜಿತವಾಗುತ್ತದೆ

1059
00:59:28,000 --> 00:59:31,000
ಆದ್ದರಿಂದ ನಾವು, ಜನರು wraparound ತೋರಿಸಬಹುದಿತ್ತು

1060
00:59:31,000 --> 00:59:35,000
ಮತ್ತು ನಾವು, ವೃತ್ತಾಕಾರದ ರಚನೆಯು ಕೆಲವು ರೀತಿಯ ನಿಜವಾಗಿಯೂ ಈ ರಚನೆಯ ಯೋಚಿಸಬಹುದು

1061
00:59:35,000 --> 00:59:38,000
ಆದರೆ ನಾವು wraparound ಆ ರೀತಿಯ ಮಾಡಲು ಸಿ ಯಾವ ಆಯೋಜಕರು ಬಳಸಲು?

1062
00:59:38,000 --> 00:59:40,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿಕ್ರಿಯೆ] >> ಪ್ರಮಾಣ ಆಯೋಜಕರು.

1063
00:59:40,000 --> 00:59:43,000
ಇದು ನೀವು wraparound ಹೇಗೆ ಮಾಡಬೇಕು ಮೂಲಕ ಯೋಚಿಸುವುದು ಸ್ವಲ್ಪ ಕಿರಿಕಿರಿ ಎಂದು

1064
00:59:43,000 --> 00:59:46,000
ಆದರೆ, ನಾವು ಮಾಡಬಹುದಾದ, ಮತ್ತು ನಾವು ಸಾಲಿನ ಮುಂಭಾಗದಲ್ಲಿ ಎಂದು ಯಾವ ಜನರು ಪುಟ್ಟಿಂಗ್ ಆರಂಭಿಸುವುದಕ್ಕಿಂತ

1065
00:59:46,000 --> 00:59:52,000
ಆದರೆ ನಾವು ಸಾಲಿನ ಹೆಡ್ ನಿಜವಾಗಿಯೂ ಯಾರು ಈ ತಲೆ ವೇರಿಯಬಲ್ ಜೊತೆ ನೆನಪಿಡಿ.

1066
00:59:52,000 --> 00:59:57,000
ಏನು, ಆದರೂ, ನಮ್ಮ ಗುರಿಯು ಅಂತಿಮವಾಗಿ, ಬದಲಿಗೆ, ವೇಳೆ

1067
00:59:57,000 --> 01:00:00,000
, ನಾವು ಅನಿತಾ ವೇದಿಕೆಯ ಮೇಲೆ ಇಲ್ಲಿ ಮಾಡಿದಂತೆ, ಸಂಖ್ಯೆಗಳು ಹುಡುಕುವ ಆಗಿತ್ತು

1068
01:00:00,000 --> 01:00:02,000
ಆದರೆ ನಿಜವಾಗಿಯೂ ಈ ಪ್ರಪಂಚದ ಅತ್ಯುತ್ತಮ ಬಯಸುವ?

1069
01:00:02,000 --> 01:00:05,000
ನಾವು ಸರಣಿ ಅನುಮತಿಸುತ್ತದೆ ಹೆಚ್ಚು ಕುತರ್ಕದಲ್ಲಿ ಬಯಸುವ

1070
01:00:05,000 --> 01:00:09,000
ನಾವು ಸಕ್ರಿಯವಾಗಿ ಅಕ್ಷಾಂಶ ರಚನೆ ಬೆಳೆಯುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಯಸುವ ಕಾರಣ.

1071
01:00:09,000 --> 01:00:12,000
ಆದರೆ ನಾವು ಗಮನಸೆಳೆದಿದ್ದಾರೆ ಆ ಅವಲಂಬಿಸಬೇಕಾಯಿತು ಹೊಂದಿರುತ್ತವೆ ಬಯಸುವುದಿಲ್ಲ

1072
01:00:12,000 --> 01:00:15,000
ಮೊದಲ ಉಪನ್ಯಾಸ ರಲ್ಲಿ, ಒಂದು ಪ್ರಶಸ್ತವಾದ ಅಲ್ಗಾರಿದಮ್ ಅಲ್ಲ

1073
01:00:15,000 --> 01:00:17,000
ರೇಖೀಯ ಹುಡುಕಾಟ ಆ.

1074
01:00:17,000 --> 01:00:21,000
ನೀವು, ವಾಸ್ತವವಾಗಿ, ಸಾಧಿಸಬಹುದು ಎಂದು ತಿರುಗುತ್ತದೆ

1075
01:00:21,000 --> 01:00:24,000
ಅಥವಾ ಕನಿಷ್ಠ ಸ್ಥಿರ ಸಮಯಕ್ಕೆ ಮುಚ್ಚಿ, ಆ ಮೂಲಕ ಅನಿತಾ ನಂತಹ ಯಾರಾದರೂ,

1076
01:00:24,000 --> 01:00:27,000
ತನ್ನ ಅಕ್ಷಾಂಶ ರಚನೆ ಸಂರಚಿಸುತ್ತದೆ ವೇಳೆ ಜೊತೆಗೂಡಿದ ಪಟ್ಟಿಯಾಗಿ ಎಂದು ಅಲ್ಲ,

1077
01:00:27,000 --> 01:00:30,000
ಒಂದು ಸ್ಟಾಕ್ ಎಂದು ಅಲ್ಲ, ಒಂದು ಕ್ಯೂ ಎಂದು ಅಲ್ಲ, ಸಾಧ್ಯವೋ, ವಾಸ್ತವವಾಗಿ,

1078
01:00:30,000 --> 01:00:33,000
, ತನ್ನ ವಸ್ತುಗಳನ್ನು ಹುಡುಕುವ ಅನುಮತಿಸುವ ಡೇಟಾ ರಚನೆ ಮಂದಿ

1079
01:00:33,000 --> 01:00:37,000
ಸಹ ಪದಗಳನ್ನು, ಕೇವಲ ಸಂಖ್ಯೆಗಳನ್ನು, ಎಂಬುದನ್ನು ನಾವು ನಿರಂತರ ಸಮಯದಲ್ಲಿ ಕರೆ ಮಾಡುತ್ತೇವೆ.

1080
01:00:37,000 --> 01:00:40,000
>> ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಮುಂದೆ ನೋಡಲು, ಈ ವರ್ಗದ psets ಒಂದು ಹೆಚ್ಚೂಕಮ್ಮಿ ಯಾವಾಗಲೂ

1081
01:00:40,000 --> 01:00:43,000
ಒಂದು spellchecker ಅಳವಡಿಕೆಯಾಗಿದೆ, ಆ ಮೂಲಕ

1082
01:00:43,000 --> 01:00:46,000
ನಾವು ಮತ್ತೆ ಕೆಲವು 150,000 ಇಂಗ್ಲೀಷ್ ಪದಗಳು ನಿಮ್ಮ ನೀಡಿ ಗೋಲು ಹೊಂದಿದೆ

1083
01:00:46,000 --> 01:00:51,000
ಮೆಮೊರಿಗೆ ಆ ಲೋಡ್ ಮತ್ತು ವೇಗವಾಗಿ ರಚನೆಯಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ

1084
01:00:51,000 --> 01:00:54,000
ಈ ಪದ ಸರಿಯಾಗಿ ಬರೆಯಲಾಗಿದೆ?

1085
01:00:54,000 --> 01:00:58,000
ನೀವು ಉತ್ತರಿಸಲು ಎಲ್ಲಾ 150,000 ಪದಗಳ ಮೂಲಕ ಮರಳಿ ಬಂತು ಅದು ನಿಜವಾಗಿಯೂ ಹೀರುವಂತೆ ಎಂದು.

1086
01:00:58,000 --> 01:01:02,000
ಆದರೆ, ವಾಸ್ತವವಾಗಿ, ನಾವು ಅತಿ ಶೀಘ್ರ ಸಮಯದಲ್ಲಿ ಇದು ಮಾಡಬಹುದು ಎಂದು ನೋಡುತ್ತಾರೆ.

1087
01:01:02,000 --> 01:01:06,000
ಮತ್ತು ಇದು ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಎಂಬ ಅನುಷ್ಠಾನಕ್ಕೆ ಏನೋ, ನಡೆಸುವಂತೆ ವಿಶೇಷವೇನು

1088
01:01:06,000 --> 01:01:09,000
ಮತ್ತು ಮೊದಲ ನೋಟದಲ್ಲಿ ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಎಂಬ ಈ ವಿಷಯ ಹೋಗಿ ಅಲ್ಲಿ ಕೂಡ

1089
01:01:09,000 --> 01:01:12,000
ಈ ಸೂಪರ್ ಶೀಘ್ರ ಪ್ರತಿಕ್ರಿಯೆ ಬಾರಿ ನಮಗೆ ಸಾಧಿಸಲು ಅವಕಾಶ

1090
01:01:12,000 --> 01:01:18,000
ಇದು ಒಂದು ಸಮಸ್ಯೆ ವಾಸ್ತವವಾಗಿ ಎಂದು ಔಟ್ ಆರಂಭಿಸುತ್ತದೆ.

1091
01:01:18,000 --> 01:01:23,000
ಇದನ್ನು ಮತ್ತೆ ಎಂದು ಈ ವಿಷಯ ಅಳವಡಿಸಲು ಸಮಯ ಬಂದಾಗ, ನಾನು ಮತ್ತೆ ಮಾಡುತ್ತಿರುವೆ.

1092
01:01:23,000 --> 01:01:25,000
ನಾನು ಇಲ್ಲಿ ಕೇವಲ ಒಂದು ಆಮ್.

1093
01:01:25,000 --> 01:01:28,000
ಅದು ಬಂದಾಗ ಈ ಸಂಗತಿ ಅನುಷ್ಠಾನಕ್ಕೆ ಸಮಯ, ಒಂದು ಹ್ಯಾಷ್ ಟೇಬಲ್ ಎಂಬ

1094
01:01:28,000 --> 01:01:30,000
ನಾವು ನಿರ್ಣಯ ಮಾಡಬೇಕು ಎಂದು ನೀನು.

1095
01:01:30,000 --> 01:01:32,000
ಈ ವಿಷಯದಲ್ಲಿ ನಿಜವಾಗಿ ಎಷ್ಟು ದೊಡ್ಡದು ಇರಬೇಕು?

1096
01:01:32,000 --> 01:01:36,000
ಮತ್ತು ನಾವು ಈ ಹ್ಯಾಶ್ ಟೇಬಲ್ಲಿಗೆ ತೂರಿಸುವ ಸಂಖ್ಯೆಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ,

1097
01:01:36,000 --> 01:01:38,000
ಹೇಗೆ ನಾವು ರೀತಿಯಲ್ಲಿ ಅವುಗಳನ್ನು ಶೇಖರಿಸಿಡಲು ಹೋಗುವ

1098
01:01:38,000 --> 01:01:42,000
ನಾವು ಅವರಿಗೆ ದೊರೆತಿದೆ ಎಂದು ನಾವು ಬೇಗನೆ ಅವರನ್ನು ಮರಳಿ ಪಡೆಯಲು ಎಂದು?

1099
01:01:42,000 --> 01:01:45,000
ಆದರೆ ನಾವು ಬಹಳ ಹಿಂದೆ ನೋಡುತ್ತಾರೆ ಎಂದು ಈ ಪ್ರಶ್ನೆ

1100
01:01:45,000 --> 01:01:48,000
ಎಲ್ಲರ ಹುಟ್ಟುಹಬ್ಬದ ವರ್ಗ ಸಮಯದಲ್ಲಿ ಸಾಕಷ್ಟು ಸಂಗತ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

1101
01:01:48,000 --> 01:01:51,000
ಇದು, ಈ ಕೋಣೆಯಲ್ಲಿ, ನಾವು ನೂರು ಜನರು ಮಾಡಲೇಬೇಕು ಎಂದು ತಿರುಗುತ್ತದೆ

1102
01:01:51,000 --> 01:01:56,000
ನಮಗೆ ಎರಡು ಒಂದೇ ಹುಟ್ಟುಹಬ್ಬದ ಪ್ರಾಯಶಃ ಬಹಳ ಹೆಚ್ಚು ಹೊಂದಿರುವ ಆಡ್ಸ್ ಆದ್ದರಿಂದ.

1103
01:01:56,000 --> 01:01:58,000
ಕೇವಲ 40 ನಮಗೆ ಈ ಕೋಣೆಯಲ್ಲಿ ಇದ್ದವು ಹೀಗಾದರೆ?

1104
01:01:58,000 --> 01:02:02,000
ಅದೇ ಹುಟ್ಟುಹಬ್ಬದ ಹೊಂದಿರುವ ಎರಡು ಜನರ ಆಡ್ಸ್ ಯಾವುವು?

1105
01:02:02,000 --> 01:02:04,000
[ವಿದ್ಯಾರ್ಥಿಗಳು] 50%.

1106
01:02:04,000 --> 01:02:06,000
ಹೌದು, 50% ಹೆಚ್ಚು. ವಾಸ್ತವವಾಗಿ, ನಾನು ಒಂದು ಚಾರ್ಟ್ ತಂದರು.

1107
01:02:06,000 --> 01:02:08,000
ಇದನ್ನು ಮತ್ತು ತಿರುಗುತ್ತದೆ ಈ ಕೇವಲ ನಿಜವಾಗಿಯೂ ಸ್ನೀಕ್ ಹೊಂದಿದೆ ಪೂರ್ವವೀಕ್ಷಣೆ-

1108
01:02:08,000 --> 01:02:12,000
ಈ ಕೋಣೆಯಲ್ಲಿ ನಮಗೆ ಕೇವಲ 58, ನಮಗೆ 2 ಸಂಭಾವ್ಯತೆ ಇಲ್ಲ ವೇಳೆ

1109
01:02:12,000 --> 01:02:16,000
ಅದೇ ಹುಟ್ಟುಹಬ್ಬದ ಹೊಂದಿರುವ, ಸುಮಾರು 100% ಅದ್ಧೂರಿ ಹೆಚ್ಚು

1110
01:02:16,000 --> 01:02:20,000
ಮತ್ತು ಬುಧವಾರ ನಮಗೆ ಹರ್ಟ್ ಒಂದು ಇಡೀ ಗುಂಪೇ ಉಂಟುಮಾಡುವ ವಿಶೇಷವೇನು.

1111
01:02:20,000 --> 01:02:24,000
>> ಎಂದು ಹೇಳಿದರು, ನ ಇಲ್ಲಿ ಮುಂದೂಡು ಅವಕಾಶ. ನಾವು ಬುಧವಾರ ನೀವು ನೋಡುತ್ತೀರಿ.

1112
01:02:24,000 --> 01:02:28,000
[ಚಪ್ಪಾಳೆಯನ್ನು]

1113
01:02:28,000 --> 01:02:30,000
[CS50.TV]