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

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

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

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

5
00:00:12,000 --> 00:00:16,000
ಮತ್ತು ಈ ನಿಧಾನವಾದ ಸಾಧ್ಯ ಬೇರ್ಪಡಿಸುವ ಕ್ರಮಾವಳಿಗಳ ಒಂದು.

6
00:00:16,000 --> 00:00:19,000
ಇದು ಒಂದು ನಾವು ಅಲ್ಲಿ ವೀಕ್ಷಿಸಿದರು ಅದು?

7
00:00:19,000 --> 00:00:24,000
ಎಂದು, (N ^ 2) + ಮೊತ್ತವು ದೊಡ್ಡ ಒ ಸಲುವಾಗಿ, ಬಬಲ್ ರೀತಿಯ

8
00:00:24,000 --> 00:00:28,000
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ನಾವು ತಿಳಿಯಲು ತೋರುತ್ತದೆ ಈ ಜಗತ್ತಿನಲ್ಲಿ ಮಾತ್ರ ಅಲ್ಲ

9
00:00:28,000 --> 00:00:30,000
ಯಾವ ಬಬಲ್ ರೀತಿಯ ಅಥವಾ ತನ್ನ ಚಾಲನೆಯ ಸಮಯ.

10
00:00:30,000 --> 00:00:33,000
ವಾಸ್ತವವಾಗಿ, ಈ ಗೂಗಲ್ನ ಎರಿಕ್ ಸ್ಮಿತ್ ಸಂದರ್ಶನದಲ್ಲಿ ಆಗಿತ್ತು

11
00:00:33,000 --> 00:00:45,000
ಮತ್ತು ಹಿಂದಿನ ಸೆನೇಟರ್ ಬರಾಕ್ ಒಬಾಮಾ ಕೇವಲ ಕೆಲವು ವರ್ಷಗಳ ಹಿಂದೆ.

12
00:00:45,000 --> 00:00:48,000
>> ಈಗ, ಸೆನೆಟರ್, ನೀವು Google ನಲ್ಲಿ ಇಲ್ಲಿ ನೀವು

13
00:00:48,000 --> 00:00:54,000
ಮತ್ತು ನಾನು ಕೆಲಸ ಸಂದರ್ಶನ ಅಧ್ಯಕ್ಷತೆಯಲ್ಲಿ ಬಗ್ಗೆ ಯೋಚಿಸಲು ನಾನು ಇಷ್ಟಪಡುತ್ತೇನೆ.

14
00:00:54,000 --> 00:00:58,000
ಈಗ, ಇದು ಅಧ್ಯಕ್ಷರಾಗಿ ಕೆಲಸ ಪಡೆಯುವುದು ಕಷ್ಟ, ಮತ್ತು ನೀವು ಈಗ ನಡುಗುವುದು ಮೂಲಕ ನೀನು.

15
00:00:58,000 --> 00:01:00,000
ಗೂಗಲ್ ನಲ್ಲಿ ಕೆಲಸ ಪಡೆಯಲು ಸಹ ಕಷ್ಟ.

16
00:01:00,000 --> 00:01:05,000
, ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ, ಮತ್ತು ನಾವು ನಮ್ಮ ಅಭ್ಯರ್ಥಿಗಳ ಪ್ರಶ್ನೆಗಳನ್ನು ಕೇಳಲು

17
00:01:05,000 --> 00:01:10,000
ಮತ್ತು ಈ ಒಂದು ಲ್ಯಾರಿ Schwimmer ಬಂದಿದೆ.

18
00:01:10,000 --> 00:01:14,000
ನೀವು ಹುಡುಗರಿಗೆ ನಾನು kidding ನಾನು ಭಾವಿಸುತ್ತೇನೆ? ಇದು ಬಲ ಇಲ್ಲಿ.

19
00:01:14,000 --> 00:01:18,000
ಒಂದು ಮಿಲಿಯನ್ 32-ಬಿಟ್ ಪೂರ್ಣಾಂಕಗಳ ವಿಂಗಡಿಸಲು ಅತ್ಯಂತ ಸಮರ್ಥ ರೀತಿಯಲ್ಲಿ ಏನು?

20
00:01:18,000 --> 00:01:21,000
[ನಗು]

21
00:01:21,000 --> 00:01:24,000
ಉತ್ತಮ

22
00:01:24,000 --> 00:01:26,000
ಕ್ಷಮಿಸಿ. >> ಇಲ್ಲ, ಇಲ್ಲ, ಇಲ್ಲ, ಇಲ್ಲ.

23
00:01:26,000 --> 00:01:34,000
ನಾನು ಬಬಲ್ ರೀತಿಯ ಹೋಗಲು ತಪ್ಪು ದಾರಿ ಆಗುತ್ತದೆ.

24
00:01:34,000 --> 00:01:39,000
>> ಅವರನ್ನು ಈ ನೀಡಿದ ಮೇಲೆ ಕಮ್?

25
00:01:39,000 --> 00:01:43,000
ಕಳೆದ ವಾರ, ನಾವು ಕನಿಷ್ಟ ಒಂದು ದಿನ, ಕೋಡ್ ವಿರಾಮ ಮರುಪಡೆಯಲು

26
00:01:43,000 --> 00:01:46,000
ಮತ್ತು ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿ ಪರಿಹರಿಸುವ ಕೆಲವು ಉನ್ನತ ಆಲೋಚನೆಗಳನ್ನು ಮತ್ತು ಸಮಸ್ಯೆ ಕಡೆ ಗಮನ ಹರಿಸಿದ್ದರು

27
00:01:46,000 --> 00:01:49,000
ಹುಡುಕಾಟ ಮತ್ತು ವರ್ಗೀಕರಿಸುವ ಸಂದರ್ಭದಲ್ಲಿ,

28
00:01:49,000 --> 00:01:53,000
ಮತ್ತು ನಾವು ಕಳೆದ ವಾರ ಈ ಹೆಸರನ್ನು ಬಡಿ ಎಂದು ಏನೋ ಪರಿಚಯಿಸಿತು

29
00:01:53,000 --> 00:01:56,000
ಆದರೆ ಅಸಂಪಾತ ಸಂಕೇತನ, ಬಿಗ್ ಓ, ಬಿಗ್ ಒಮೆಗಾ,

30
00:01:56,000 --> 00:02:00,000
ಮತ್ತು ಕೆಲವೊಮ್ಮೆ ಬಿಗ್ ಥೀಟಾ ಸಂಕೇತ, ಮತ್ತು ಈ ಕೇವಲ ರೀತಿಯಲ್ಲಿ ಎಂದು

31
00:02:00,000 --> 00:02:02,000
ಕ್ರಮಾವಳಿಗಳ ಚಾಲನೆಯ ಸಮಯ ವಿವರಿಸುವ,

32
00:02:02,000 --> 00:02:05,000
ಚಲಾಯಿಸಲು ಒಂದು ಕ್ರಮಾವಳಿ ಬೇಕಾಗುತ್ತದೆ ಎಷ್ಟು ಸಮಯ.

33
00:02:05,000 --> 00:02:08,000
>> ಮತ್ತು ನೀವು ಗಾತ್ರದ ವಿಚಾರದಲ್ಲಿ ನೀವು ಚಲಾಯಿಸುತ್ತಿರುವ ಸಮಯದ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಸ್ಮರಿಸಿಕೊಳ್ಳಲು

34
00:02:08,000 --> 00:02:11,000
ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಸಮಸ್ಯೆ ಇರಬಹುದು ಇರಲಿ, N ಕರೆ ಇದು ಇನ್ಪುಟ್, ರ,

35
00:02:11,000 --> 00:02:13,000
ಅಲ್ಲಿ N, ಕೋಣೆಯಲ್ಲಿ ಜನರ ಸಂಖ್ಯೆ

36
00:02:13,000 --> 00:02:17,000
ಫೋನ್ ಪುಸ್ತಕದಲ್ಲಿ ಪುಟಗಳ ಸಂಖ್ಯೆ, ಮತ್ತು ನಾವು ಕಾಣುವುದು ಬರೆಯಲಾರಂಭಿಸಿದ್ದರು

37
00:02:17,000 --> 00:02:21,000
ಓ ನಂತಹ (N ^ 2) ಅಥವಾ O (N) ಅಥವಾ O (N ಲಾಗ್ N),

38
00:02:21,000 --> 00:02:24,000
ಮತ್ತು ಗಣಿತ ಅಷ್ಟೊಂದು ಸಂಪೂರ್ಣವಾಗಿ ಔಟ್ ಕೈಗೂಡಲಿಲ್ಲ ಸಹ

39
00:02:24,000 --> 00:02:28,000
ಮತ್ತು N ಆಗಿತ್ತು ² - N / 2 ಅಥವಾ ಆ ರೀತಿಯ

40
00:02:28,000 --> 00:02:31,000
ನಾವು ಕೇವಲ, ಕೆಳ ಕ್ರಮಾಂಕದ ಪದಗಳ ದೂರ ಎಸೆಯುತ್ತಾರೆ

41
00:02:31,000 --> 00:02:34,000
ಮತ್ತು ಪ್ರೇರಣೆ ನಾವು ನಿಜವಾಗಿಯೂ ಬಯಸುವ ಇಲ್ಲ

42
00:02:34,000 --> 00:02:37,000
ಮೌಲ್ಯಮಾಪನವನ್ನು ವಸ್ತುನಿಷ್ಠ ರೀತಿಯಲ್ಲಿ ರೀತಿಯ

43
00:02:37,000 --> 00:02:39,000
ಕಾರ್ಯಕ್ರಮಗಳ ಪ್ರದರ್ಶನ ಅಥವಾ ಕ್ರಮಾವಳಿಗಳ ಪ್ರದರ್ಶನ

44
00:02:39,000 --> 00:02:42,000
ಆ ದಿನದ ಅಂತ್ಯದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ಯಾವುದೇ ಸಂಬಂಧವಿಲ್ಲ

45
00:02:42,000 --> 00:02:45,000
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ವೇಗವನ್ನು ಇಂದು.

46
00:02:45,000 --> 00:02:47,000
>> ಉದಾಹರಣೆಗೆ, ನೀವು ಬಬಲ್ ರೀತಿಯ ಜಾರಿಗೆ ವೇಳೆ,

47
00:02:47,000 --> 00:02:50,000
ಅಥವಾ ನೀವು, ಇಂದಿನ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ ರೀತಿಯ ಅಥವಾ ಆಯ್ಕೆ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ಜಾರಿಗೆ

48
00:02:50,000 --> 00:02:53,000
ಒಂದು 2 GHz ಕಂಪ್ಯೂಟರ್, ಮತ್ತು ನೀವು ಚಾಲನೆ

49
00:02:53,000 --> 00:02:56,000
ಮತ್ತು ಇದು 3 GHz ಇಲ್ಲ ಮುಂದಿನ ವರ್ಷ, ಸೆಕೆಂಡುಗಳಲ್ಲಿ ಕೆಲವು ಸಂಖ್ಯೆಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

50
00:02:56,000 --> 00:02:59,000
ಅಥವಾ 4 GHz ಕಂಪ್ಯೂಟರ್, ಮತ್ತು ನೀವು ಆ "ವಾಹ್, ನನ್ನ ಅಲ್ಗಾರಿದಮ್ ವಾದಿಸಬಹುದಿತ್ತು

51
00:02:59,000 --> 00:03:03,000
ವಾಸ್ತವದಲ್ಲಿ ಆ ಸಂದರ್ಭದಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಅಲ್ಲ ಯಾವಾಗ ", ಎರಡು ಬಾರಿ ವೇಗವಾಗಿ ಈಗ.

52
00:03:03,000 --> 00:03:06,000
ಇದು ಕೇವಲ ಹಾರ್ಡ್ವೇರ್ ವೇಗವಾಗಿ ನೆತ್ತಿಗೇರಿದೆ ನೀಡಿದ್ದಾರೆ, ಆದರೆ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್

53
00:03:06,000 --> 00:03:10,000
, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ವಿಷಯಗಳನ್ನು ಎಸೆದು ಬಯಸುವ ಇಲ್ಲ

54
00:03:10,000 --> 00:03:13,000
2 ದ್ವಿಗುಣ ಅಥವಾ 3 ದ್ವಿಗುಣ ಅದನ್ನು ವಿವರಿಸಲು ಬಂದಾಗ

55
00:03:13,000 --> 00:03:17,000
ಎಷ್ಟು ವೇಗವಾಗಿ ಅಥವಾ ಹೇಗೆ ನಿಧಾನವಾಗಿ ಒಂದು ಕ್ರಮಾವಳಿ ಮತ್ತು ನಿಜವಾಗಿಯೂ ಕೇವಲ ಗಮನ

56
00:03:17,000 --> 00:03:20,000
N ಅಥವಾ ಅದರ ಕೆಲವು ಅಂಶವು ಮೇಲೆ

57
00:03:20,000 --> 00:03:24,000
ಕೆಲವು ವಿದ್ಯುತ್ ಅದರ ಕೊನೆಯ ವಾರದ ರೀತಿಯ ವಿಷಯದಲ್ಲಿ.

58
00:03:24,000 --> 00:03:27,000
ಮತ್ತು ವಿಲೀನ ರೀತಿಯ ಸಹಾಯದಿಂದ ಸ್ಮರಿಸುತ್ತಾರೆ

59
00:03:27,000 --> 00:03:31,000
ನಾವು ಬಬಲ್ ರೀತಿಯ ಮತ್ತು ಆಯ್ಕೆಯ ರೀತಿಯ ಗಿಂತ ತುಂಬಾ ಚೆನ್ನಾಗಿ ಸಮರ್ಥರಾದರು

60
00:03:31,000 --> 00:03:33,000
ಮತ್ತು ಅಳವಡಿಕೆಯ ರೀತಿಯ.

61
00:03:33,000 --> 00:03:36,000
>> ನಾವು, ಮತ್ತೆ N ಲಾಗ್ N ಕೆಳಗೆ ಪಡೆದರು, ಮತ್ತು

62
00:03:36,000 --> 00:03:39,000
ಲಾಗ್ N ಸಾಮಾನ್ಯವಾಗಿ ಬೆಳೆಯುತ್ತದೆ ಏನೋ ಸೂಚಿಸುತ್ತದೆ ಸ್ಮರಿಸುತ್ತಾರೆ

63
00:03:39,000 --> 00:03:43,000
ನಿಧಾನವಾಗಿ ನಂತರ N, ಆದ್ದರಿಂದ N ಲಾಗ್ N ಇದುವರೆಗಿನ ಚೆನ್ನಾಗಿತ್ತು

64
00:03:43,000 --> 00:03:45,000
ಇದು n ² ಕಡಿಮೆ ಕಾರಣ.

65
00:03:45,000 --> 00:03:47,000
ಆದರೆ ವಿಲೀನ ರೀತಿಯ n ಜೊತೆಗೆ ಸಾಧಿಸಲು N ಪ್ರವೇಶಿಸಲು

66
00:03:47,000 --> 00:03:51,000
ನಾವು ನಿಯಂತ್ರಣ ಎಂಬ ಕಲ್ಪನೆಯನ್ನು ಮೂಲ ಜೀವಾಂಕುರ ಆಗಿದ್ದದ್ದು

67
00:03:51,000 --> 00:03:54,000
ನಾವು ವಾರದ 0 ಮತ್ತೆ ಸಾಲವನ್ನು ಎಂದು?

68
00:03:54,000 --> 00:03:58,000
ಹೇಗೆ ನಾವು ವಿಲೀನ ಗೊಳಗಾದ ಜಾಣತನದಿಂದ ವಿಂಗಡಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ನಿಭಾಯಿಸಲು ನೀಡಲಿಲ್ಲ?

69
00:03:58,000 --> 00:04:04,000
ಬಹುಶಃ, ಪ್ರಮುಖ ಒಳನೋಟವನ್ನು ಯಾವುದು?

70
00:04:04,000 --> 00:04:07,000
ಯಾರಾದರೂ ಎಲ್ಲಾ ನಲ್ಲಿ.

71
00:04:07,000 --> 00:04:09,000
ಸರಿ, ಹಿಂದಿನ ಒಂದು ಹಂತದ ನೋಡೋಣ.

72
00:04:09,000 --> 00:04:11,000
ನಿಮ್ಮ ಮಾತಿನಲ್ಲಿ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ವಿವರಿಸಿ.

73
00:04:11,000 --> 00:04:15,000
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ?

74
00:04:15,000 --> 00:04:17,000
ಸರಿ, ನಾವು ವಾರದ 0 ಮತ್ತೆ ಸಾಲನ್ನು ಮಾಡುತ್ತೇವೆ.

75
00:04:17,000 --> 00:04:19,000
ಸರಿ, ಹೌದು.

76
00:04:19,000 --> 00:04:22,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

77
00:04:22,000 --> 00:04:26,000
ಉತ್ತಮ, ಸರಿ, ಆದ್ದರಿಂದ ನಾವು 2 ತುಂಡುಗಳಾಗಿ ಸಂಖ್ಯೆಗಳ ರಚನೆಯ ವಿಂಗಡಿಸಲಾಗಿದೆ.

78
00:04:26,000 --> 00:04:29,000
, ನಾವು ಆ ಕಾಯಿಗಳ ಪ್ರತಿ ವಿಂಗಡಿಸಿ, ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ವಿಲೀನಗೊಂಡಿತು

79
00:04:29,000 --> 00:04:33,000
ಈ ದೊಡ್ಡ ಎಂದು ಸಮಸ್ಯೆ ತೆಗೆದುಕೊಳ್ಳುವ ಮೊದಲು ನಾವು ಈ ಕಲ್ಪನೆಯನ್ನು ನೋಡಬಹುದು

80
00:04:33,000 --> 00:04:36,000
ಮತ್ತು ಈ ದೊಡ್ಡ ಅಥವಾ ಈ ದೊಡ್ಡ ಎಂದು ಸಮಸ್ಯೆ ಅದನ್ನು ಕುಯ್ಯುವ.

81
00:04:36,000 --> 00:04:38,000
>> ಫೋನ್ ಪುಸ್ತಕ ಉದಾಹರಣೆಗೆ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

82
00:04:38,000 --> 00:04:42,000
, ಹಿಂದೆ ವಾರಗಳಿಂದ ಸ್ವಯಂ ಎಣಿಕೆಯ ಅಲ್ಗಾರಿದಮ್ ಮರುಪಡೆಯಲು

83
00:04:42,000 --> 00:04:45,000
ಆದ್ದರಿಂದ ವಿಲೀನಗೊಳ್ಳಲು ರೀತಿಯ ಇಲ್ಲಿ ಈ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಅದಕ್ಕೆ ಸಾರಾಂಶಗೊಳಿಸಲಾಗಿದೆ.

84
00:04:45,000 --> 00:04:48,000
ನೀವು N ಅಂಶಗಳನ್ನು ನೀಡಲಾಗಿದೆ ಮಾಡಿದಾಗ, ಮೊದಲು ವಿವೇಕ ತಡೆಯಾಗಿತ್ತು.

85
00:04:48,000 --> 00:04:51,000
N <2 ನಂತರ ಎಲ್ಲ ಏನು ಮಾಡದಿದ್ದರೆ

86
00:04:51,000 --> 00:04:55,000
N <2 ನಂತರ N ನಿಸ್ಸಂಶಯವಾಗಿ 0 ಅಥವಾ 1 ವೇಳೆ ಏಕೆಂದರೆ,

87
00:04:55,000 --> 00:04:57,000
ಅದು ಇದ್ದರೆ ಆದ್ದರಿಂದ 0 ಅಥವಾ 1 ವಿಂಗಡಿಸಲು ಇಲ್ಲ.

88
00:04:57,000 --> 00:04:59,000
ನೀವು ಮುಗಿಸಿದ್ದೀರಿ.

89
00:04:59,000 --> 00:05:01,000
ನಿಮ್ಮ ಪಟ್ಟಿಯನ್ನು ಈಗಾಗಲೇ ಒಂದಲ್ಲ ವಿಂಗಡಿಸಲ್ಪಡುತ್ತದೆ.

90
00:05:01,000 --> 00:05:04,000
ಆದರೆ ನೀವು 2 ಅಥವಾ ಹೆಚ್ಚು ಅಂಶಗಳನ್ನು ಪಡೆದಿರುವಿರಿ ಮೇಲಿಂಗ್ ವೇಳೆ ಮುಂದೆ ಹೋಗಿ ಅವರನ್ನು ಬೇರ್ಪಡಿಸುತ್ತದೆ

91
00:05:04,000 --> 00:05:06,000
2 ಅರ್ಥ ಒಳಗೆ, ಎಡ ಮತ್ತು ಬಲ.

92
00:05:06,000 --> 00:05:09,000
ಆ ಅರ್ಥ ಪ್ರತಿ ವಿಂಗಡಿಸಲು, ಮತ್ತು ಅದನ್ನು ನಂತರ ವಿಂಗಡಿಸಿ ಅರ್ಥ ವಿಲೀನಗೊಳ್ಳಲು.

93
00:05:09,000 --> 00:05:13,000
ಆದರೆ ಇಲ್ಲಿ ಸಮಸ್ಯೆ ನಾವು ವಿಶಿಷ್ಟ ಗುರುತನ್ನು ಮಾಡುತ್ತಿರುವಂತೆ ಮೊದಲ ನೋಟದಲ್ಲಿ ಈ ಭಾವಿಸುವ ಹೊಂದಿದೆ.

94
00:05:13,000 --> 00:05:17,000
ನಾನು ಈ N ಅಂಶಗಳನ್ನು ವಿಂಗಡಿಸಲು ನೀವು ಕೇಳಿದ್ದೀರಿ ವೇಳೆ ಇದು ಒಂದು ವೃತ್ತಾಕಾರದ ವ್ಯಾಖ್ಯಾನ

95
00:05:17,000 --> 00:05:22,000
ಮತ್ತು ನೀವು ", ಆಲ್ ರೈಟ್, ದಂಡ, ನಾವು ಆ N / 2 ಮತ್ತು ಆ N / 2 ಅಂಶಗಳನ್ನು ವಿಂಗಡಿಸಲು ನೀವು" ಹೇಳುತಿದ್ದಾರೆ

96
00:05:22,000 --> 00:05:27,000
ನಂತರ ನನ್ನ ಮುಂದಿನ ಪ್ರಶ್ನೆ ಎಂದು ಹೋಗುತ್ತದೆ "ಹೇಗೆ ನೀವು N / 2 ಅಂಶಗಳನ್ನು ವಿಂಗಡಿಸಲು ಇಲ್ಲ, ಫೈನ್?"

97
00:05:27,000 --> 00:05:30,000
>> ಆದರೆ ಈ ಕಾರ್ಯಕ್ರಮದ ರಚನೆಯ,

98
00:05:30,000 --> 00:05:33,000
ಈ ಮೂಲ ಕೇಸ್ ಇರುವುದರಿಂದ, ಆದ್ದರಿಂದ ಮಾತನಾಡಲು

99
00:05:33,000 --> 00:05:39,000
N ತಕ್ಷಣವೇ 2 ರಿಟರ್ನ್ ಕೆಲವು ಸ್ಥಿರ ಮೌಲ್ಯ <ಎಂದು ಹೇಳುತ್ತದೆ ಈ ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ.

100
00:05:39,000 --> 00:05:42,000
ಅದೇ ವೃತ್ತಾಕಾರದ ಉತ್ತರವನ್ನು ಪ್ರತಿಕ್ರಿಯೆ ಇಲ್ಲ.

101
00:05:42,000 --> 00:05:46,000
ಈ ಪ್ರಕ್ರಿಯೆ, ಈ cyclicity ಅಂತಿಮವಾಗಿ ಮುಕ್ತಾಯಗೊಳ್ಳಲಿವೆ.

102
00:05:46,000 --> 00:05:50,000
ನಾನು "ವಿಂಗಡಿಸಿ ಈ N ಅಂಶಗಳು," ನೀವು ಕೇಳಲು ಮತ್ತು ನೀವು ಹೇಳುವ ವೇಳೆ "ಫೈನ್, ಈ N / 2 ವಿಂಗಡಿಸಲು"

103
00:05:50,000 --> 00:05:53,000
ನಂತರ ನೀವು "ಫೈನ್, ಈ ರೀತಿಯ N / 4, N / 8, n/16," ಸೇ

104
00:05:53,000 --> 00:05:56,000
ಅಂತಿಮವಾಗಿ ನೀವು ದೊಡ್ಡ ಸಾಕಷ್ಟು ಸಂಖ್ಯೆಯಿಂದ ಭಾಗಿಸಿದಾಗ ವಿಲ್

105
00:05:56,000 --> 00:05:59,000
ನೀವು ಹೇಳಬಹುದು ಯಾವ, ಕೇವಲ 1 ಅಂಶ ಎಡ ಎಂಬುದನ್ನು

106
00:05:59,000 --> 00:06:02,000
"ಇಲ್ಲಿ, ಇಲ್ಲಿ ವಿಂಗಡಿಸಲಾದ ಏಕ ಅಂಶ ಹೊಂದಿದೆ."

107
00:06:02,000 --> 00:06:06,000
ಈ ಕ್ರಮಾವಳಿಯ ಕಾಂತಿ ಅಪ್ ಇಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಹುಟ್ಟಿಕೊಂಡ ಆಗಿದೆ

108
00:06:06,000 --> 00:06:09,000
ಎಂದು ಒಮ್ಮೆ ನೀವು ಈ ಪ್ರತ್ಯೇಕವಾಗಿ ವಿಂಗಡಿಸಲಾದ ಪಟ್ಟಿಗಳನ್ನು ಎಲ್ಲಾ ಹೊಂದಿದ್ದು,

109
00:06:09,000 --> 00:06:12,000
ಅನುಪಯುಕ್ತ ತೋರುತ್ತದೆ ಇದು ಗಾತ್ರ 1, ಅವುಗಳನ್ನು ಎಲ್ಲಾ,

110
00:06:12,000 --> 00:06:15,000
ನೀವು ಅವುಗಳನ್ನು ಮರ್ಜಿಂಗ್ ಮತ್ತು ಅವುಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವ ಆರಂಭಿಸಲು ಒಮ್ಮೆ

111
00:06:15,000 --> 00:06:19,000
ರಾಬ್ ವೀಡಿಯೊ ಅಂತಿಮವಾಗಿ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಮಾಡಿದಂತೆಯೇ ನೀವು ಅಂತಿಮವಾಗಿ ನಿರ್ಮಿಸಲು.

112
00:06:19,000 --> 00:06:22,000
>> ಆದರೆ ಈ ಕಲ್ಪನೆ ತುಂಬಾ ಬೇರ್ಪಡಿಸುವ ಮೀರಿ ವಿಸ್ತರಿಸಿದೆ.

113
00:06:22,000 --> 00:06:26,000
ರಿಕರ್ಶನ್ ಎಂದು ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಎಂಬೆಡೆಡ್ ಈ ಕಲ್ಪನೆಯು, ಇಲ್ಲ

114
00:06:26,000 --> 00:06:29,000
ನೀವು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಹಕ್ಕಿಯು ಕಲ್ಪನೆ,

115
00:06:29,000 --> 00:06:32,000
ಮತ್ತು ನಿಮ್ಮ ಕರೆ ಕೆಲವು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು,

116
00:06:32,000 --> 00:06:36,000
ಅಥವಾ, ನೀವು ಕಾರ್ಯಗಳಾಗಿವೆ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಸಂದರ್ಭದಲ್ಲಿ ಪುಟ್

117
00:06:36,000 --> 00:06:39,000
ಮತ್ತು ಸಮಸ್ಯೆ ಪರಿಹರಿಸುವ ಸಲುವಾಗಿ, ನೀವು ಕಾರ್ಯವನ್ನು ನಿಮ್ಮ ಕರೆ

118
00:06:39,000 --> 00:06:42,000
ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತೆ, ಆದರೆ ನೀವು ಕಾರ್ಯ

119
00:06:42,000 --> 00:06:44,000
ನೀವೇ ಅನಂತವಾದ ಬಾರಿ ಕರೆ ಸಾಧ್ಯವಿಲ್ಲ.

120
00:06:44,000 --> 00:06:47,000
ಅಂತಿಮವಾಗಿ ನೀವು, ಆದ್ದರಿಂದ ಮಾತನಾಡಲು, ಕೆಳಗೆ ಔಟ್ ಮಾಡಬೇಕು

121
00:06:47,000 --> 00:06:49,000
ಮತ್ತು ಹೇಳುವಂತೆ ಕೆಲವು ಹಾರ್ಡ್ ಕೋಡೆಡ್ ಬೇಸ್ ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತವೆ

122
00:06:49,000 --> 00:06:53,000
ಈ ಹಂತದಲ್ಲಿ ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕರೆ ತಡೆಯಲು ಇಡೀ ಪ್ರಕ್ರಿಯೆ

123
00:06:53,000 --> 00:06:56,000
ಅಂತಿಮವಾಗಿ ವಾಸ್ತವವಾಗಿ ನಿಲ್ಲಿಸಲು ಮಾಡುವುದಿಲ್ಲ.

124
00:06:56,000 --> 00:06:58,000
ಈ ನಿಜವಾಗಿಯೂ recurse ಗೆ, ಏನು?

125
00:06:58,000 --> 00:07:01,000
>> ನಾವು, ಹೇಳುತ್ತಾರೆ, ಜೊತೆಗೆ ಒಂದು ಸರಳ, ಕ್ಷುಲ್ಲಕ ಉದಾಹರಣೆಗೆ ಸಾಧ್ಯವೇ ನೋಡೋಣ

126
00:07:01,000 --> 00:07:03,000
ಅಪ್ ಇಲ್ಲಿ ವೇದಿಕೆಯಲ್ಲಿ ನನ್ನೊಂದಿಗೆ 3 ಜನರು, ಯಾರಾದರೂ ಆರಾಮದಾಯಕ ವೇಳೆ.

127
00:07:03,000 --> 00:07:06,000
ಅಪ್, 2 ಮತ್ತು 3 ರಂದು 1, ಬನ್ನಿ.

128
00:07:06,000 --> 00:07:09,000
ನೀವು 3 ಇಲ್ಲಿ ಬರಲು ಬಯಸಿದರೆ.

129
00:07:09,000 --> 00:07:12,000
ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಇಲ್ಲಿ ನನಗೆ ಹಕ್ಕನ್ನು ಮುಂದಿನ ನಿಲ್ಲಲು ಬಯಸಿದರೆ, ಇಟ್ಟುಕೋ ಎಂದು ಕೈಯಲ್ಲಿ ಸಮಸ್ಯೆ

130
00:07:12,000 --> 00:07:15,000
ತುಂಬಾ ಒಂದಲ್ಲ ಇಲ್ಲಿ ಜನರಿಗೆ ಸಂಖ್ಯೆಯನ್ನು ಇದೆ.

131
00:07:15,000 --> 00:07:18,000
ಆದರೆ ಸರಳವಾಗಿ, ನಾನು ಈ ಎಣಿಸುವ ಉದಾಹರಣೆಗಳು ದಣಿದ ಆಗಿದ್ದೇನೆ.

132
00:07:18,000 --> 00:07:21,000
ಈ ಕೆಲವು ಸಮಯ, 1, 2, ಮತ್ತು ಡಾಟ್, ಡಾಟ್, ಡಾಟ್ ತೆಗೆದುಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ.

133
00:07:21,000 --> 00:07:23,000
ಇದು ಶಾಶ್ವತವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವುದು.

134
00:07:23,000 --> 00:07:25,000
ನಾನು ಸಹಾಯ ಒಟ್ಟಿಗೆ ಓಡ ಈ ಸಮಸ್ಯೆಯ-ನಿಮ್ಮ ಹೆಸರು '? ಬದಲಿಗೆ ಬಯಸುವ

135
00:07:25,000 --> 00:07:27,000
ಸಾರಾ. >> ಸಾರಾ, ಸರಿ.

136
00:07:27,000 --> 00:07:29,000
ಕೆಲ್ಲಿ. >> ಕೆಲ್ಲಿ ಮತ್ತು?

137
00:07:29,000 --> 00:07:31,000
>> ವಿಲ್ಲಿ. >> ವಿಲ್ಲಿ, ಸಾರಾ, ಕೆಲ್ಲಿ, ಮತ್ತು ವಿಲ್ಲಿ.

138
00:07:31,000 --> 00:07:34,000
ಇದೀಗ ನಾನು ಯಾರೋ ಪ್ರಶ್ನೆ ಕೇಳಿದ್ದರೆ

139
00:07:34,000 --> 00:07:37,000
ಎಷ್ಟು ಜನರು ಈ ವೇದಿಕೆಯ ಮೇಲೆ, ಮತ್ತು ನಾನು ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

140
00:07:37,000 --> 00:07:40,000
ಇದು ನಿಜವಾಗಿಯೂ ಉದ್ದ ಪಟ್ಟಿ, ಮತ್ತು ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಈ ಟ್ರಿಕ್ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

141
00:07:40,000 --> 00:07:43,000
ನಾನು ಕೆಲಸದ ಹೆಚ್ಚು ಮಾಡಲು ನನಗೆ ಮುಂದಿನ ಕೇಳಿ ಪಡೆಯಲಿದ್ದೇನೆ

142
00:07:43,000 --> 00:07:46,000
ಮತ್ತು ಒಮ್ಮೆ ಅವಳು ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ

143
00:07:46,000 --> 00:07:49,000
ನಾನು ಸಾಧ್ಯವಾದಷ್ಟು ಕೆಲಸ ಕನಿಷ್ಠ ಪ್ರಮಾಣದ ಮಾಡಲು ಹೋಗಿ ಕೇವಲ 1 ಸೇರಿಸಲು ನಾನು

144
00:07:49,000 --> 00:07:51,000
, ಇಲ್ಲಿ ನಾವು ಹೋಗಿ ಯಾವುದೇ ತನ್ನ ಉತ್ತರವನ್ನು ಗೆ.

145
00:07:51,000 --> 00:07:54,000
ನಾನು ವೇದಿಕೆಯ ಮೇಲೆ ಎಷ್ಟು ಜನರು ಕೇಳಿದ ಮಾಡಿದ.

146
00:07:54,000 --> 00:07:57,000
ಎಷ್ಟು ಜನರನ್ನು ನೀವು ಎಡ ವೇದಿಕೆಯ ಮೇಲೆ?

147
00:07:57,000 --> 00:08:00,000
ಸರಿ >>? ನನಗೆ ಎಡ, ಆದರೆ ಮೋಸ ಮಾಡುವುದಿಲ್ಲ.

148
00:08:00,000 --> 00:08:04,000
ಅದು ಸರಿ ಎಂದು, ಒಳ್ಳೆಯದು, ಆದರೆ ನಾವು ಈ ತರ್ಕ ಮುಂದುವರೆಸಲು ಬಯಸಿದರೆ

149
00:08:04,000 --> 00:08:08,000
ನೀವು ಅದೇ ರೀತಿ ನಿಮ್ಮ ಎಡಕ್ಕೆ ಓಡ ಈ ಸಮಸ್ಯೆಯನ್ನು ಬಯಸುವ ನ ಊಹಿಸುತ್ತವೆ ಅವಕಾಶ,

150
00:08:08,000 --> 00:08:11,000
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಉತ್ತರವನ್ನು ಹೆಚ್ಚು ನೇರವಾಗಿ ಮುಂದುವರಿಯಿರಿ ಕೇವಲ ಬಕ್ ಹಾದುಹೋಗುತ್ತವೆ.

151
00:08:11,000 --> 00:08:14,000
ಓಹ್, ನನ್ನ ಎಡ ಎಷ್ಟು ಜನರು?

152
00:08:14,000 --> 00:08:16,000
ಎಡಕ್ಕೆ ಎಷ್ಟು ಜನರು?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[ನಗು]

155
00:08:27,000 --> 00:08:30,000
ಸರಿ, ಹಾಗಾಗಿ 0, ಹಾಗಾಗಿ ಈಗ ವಿಲ್ಲಿ ಮಾಡಿದ್ದಾರೆ

156
00:08:30,000 --> 00:08:33,000
ನಿಮ್ಮ ಉತ್ತರವನ್ನು 0 ಹೇಳುವ ಈ ದಿಕ್ಕಿನಲ್ಲಿ ಮರಳಿದರು ನೀವು ಇದೆ.

157
00:08:33,000 --> 00:08:36,000
ಈಗ, ನೀವು ಏನು ಮಾಡಬೇಕು? >> 1.

158
00:08:36,000 --> 00:08:39,000
ಸರಿ, ನೀವು 1 ಆರ್, ನೀವು ಹೇಳುವ, "ಸರಿ, ನಾನು 1 ಸೇರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

159
00:08:39,000 --> 00:08:41,000
ಗೆ ಯಾವುದೇ ವಿಲ್ಲಿ ನ ಎಣಿಕೆ ಆಗಿತ್ತು, "ಆದ್ದರಿಂದ 1 + 0.

160
00:08:41,000 --> 00:08:43,000
ಬಲಭಾಗದಲ್ಲಿ ನಿಮ್ಮ ಉತ್ತರವನ್ನು ಆದ್ದರಿಂದ ನೀವು ಈಗ 1 ನೀವು ಈಗ

161
00:08:43,000 --> 00:08:45,000
1. >> ಮತ್ತು ಗಣಿ 2 ಎಂದು.

162
00:08:45,000 --> 00:08:48,000
, ಆದ್ದರಿಂದ ನೀವು, 1 ಹಿಂದಿನ ಉತ್ತರವನ್ನು ಗುಡ್ ತೆಗೆದುಕೊಳ್ಳುವ ನೀವು

163
00:08:48,000 --> 00:08:51,000
ನೀವು ಬಯಸುವ ಕೆಲಸದ ಕನಿಷ್ಠ ಪ್ರಮಾಣದಲ್ಲಿ ಸೇರಿಸುವುದರಿಂದ, ಅದು +1.

164
00:08:51,000 --> 00:08:55,000
ನೀವು ಈಗ 2, ಮತ್ತು ನಂತರ ನೀವು ನನಗೆ ಯಾವ ಮೌಲ್ಯವನ್ನು ಹ್ಯಾಂಡ್?

165
00:08:55,000 --> 00:08:57,000
3, ನಾನು, ಕ್ಷಮಿಸಿ, 2 ಅರ್ಥ.

166
00:08:57,000 --> 00:08:59,000
ಗುಡ್.

167
00:08:59,000 --> 00:09:02,000
>> ಹಾಗೆಯೇ, ನಾವು ಎಡಕ್ಕೆ 0 ಹೊಂದಿತ್ತು.

168
00:09:02,000 --> 00:09:05,000
, ನಾವು 1 ಹೊಂದಿತ್ತು, ಮತ್ತು ನಂತರ ನಾವು 2 ಸೇರಿಸಿ

169
00:09:05,000 --> 00:09:07,000
ಈಗ ನೀವು ನನ್ನ ಸಂಖ್ಯೆ 2 ಹಸ್ತಾಂತರಿಸುವ ನೀವು

170
00:09:07,000 --> 00:09:10,000
ಮತ್ತು ಆದ್ದರಿಂದ ನಾನು 3, +1, ಸರಿ, ಹೇಳುವ ನುಡಿದರು.

171
00:09:10,000 --> 00:09:13,000
ಈ ವೇದಿಕೆಯಲ್ಲಿ ನನ್ನ ಪಕ್ಕದಲ್ಲಿ ನಿಂತು 3 ಜನರು ನಿಜಕ್ಕೂ ಇಲ್ಲ

172
00:09:13,000 --> 00:09:16,000
ಆದ್ದರಿಂದ ನಾವು ನಿಸ್ಸಂಶಯವಾಗಿ ಅತ್ಯಂತ ರೇಖೀಯವಾಗಿ ಈ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

173
00:09:16,000 --> 00:09:19,000
ಸ್ಪಷ್ಟ ರೀತಿಯಲ್ಲಿ ಹೆಚ್ಚು, ಆದರೆ ನಾವು ಏನು ಮಾಡಿದನು?

174
00:09:19,000 --> 00:09:21,000
ನಾವು ಆರಂಭದಲ್ಲಿ ಗಾತ್ರದ 3 ಒಂದು ತೊಂದರೆಯನ್ನು ತೆಗೆದುಕೊಂಡರು.

175
00:09:21,000 --> 00:09:24,000
ನಾವು ನಂತರ, ಗಾತ್ರ 2 ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಅದು ಮುರಿದು

176
00:09:24,000 --> 00:09:27,000
ನಂತರ ಗಾತ್ರ 1 ಒಂದು ಸಮಸ್ಯೆ, ಮತ್ತು ಆಧಾರ ಸಂದರ್ಭದಲ್ಲಿ ಅಂತಿಮವಾಗಿ

177
00:09:27,000 --> 00:09:29,000
ನಿಜವಾಗಿಯೂ ಆಗಿತ್ತು, ಓಹ್, ಯಾವುದೇ ಒಂದು, ಇಲ್ಲ

178
00:09:29,000 --> 00:09:33,000
ಬಿಂದುವನ್ನು ವಿಲ್ಲಿ, ಒಂದು ಹಾರ್ಡ್ ಕೋಡೆಡ್ ಉತ್ತರವನ್ನು ಒಂದೆರಡು ಬಾರಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮರಳಿದರು

179
00:09:33,000 --> 00:09:36,000
ಮತ್ತು ಎರಡನೆಯದು ನಂತರ ಅಪ್ bubbled, ಅಪ್ bubbled, ಅಪ್ bubbled ಮಾಡಲಾಯಿತು

180
00:09:36,000 --> 00:09:39,000
ತದನಂತರ ಈ ಒಂದು ಹೆಚ್ಚುವರಿ 1 ರಲ್ಲಿ ಸೇರಿಸುವ ಮೂಲಕ

181
00:09:39,000 --> 00:09:41,000
ನಾವು ರಿಕರ್ಶನ್ ಮೂಲ ಕಲ್ಪನೆಯನ್ನು ಜಾರಿಗೆ ಮಾಡಿದ್ದೀರಿ.

182
00:09:41,000 --> 00:09:44,000
>> ಈಗ, ಈ ಪ್ರಕರಣದಲ್ಲಿ ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಮಾಡಲಿಲ್ಲ

183
00:09:44,000 --> 00:09:46,000
ಯಾವುದೇ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ನಾವು ಇದುವರೆಗಿನ ನೋಡಿದ್ದೇವೆ.

184
00:09:46,000 --> 00:09:48,000
ಆದರೆ ಇದುವರೆಗಿನ ವೇದಿಕೆಯ ಮೇಲೆ ಮಾಡಿದ ಕ್ರಮಾವಳಿಗಳು ಬಗ್ಗೆ ಯೋಚಿಸುತ್ತಾರೆ.

185
00:09:48,000 --> 00:09:51,000
ನಾವು, chalkboard ಮೇಲೆ ಕಾಗದದ 8 ತುಣುಕುಗಳನ್ನು ಹೊಂದಿದ್ದ

186
00:09:51,000 --> 00:09:55,000
ವೀಡಿಯೊ ಸೀನ್ ಸಂಖ್ಯೆ 7 ಹುಡುಕುತ್ತಿರುತ್ತದೆ, ಮತ್ತು ಅವರು ನಿಜವಾಗಿಯೂ ಏನು ಅವರು?

187
00:09:55,000 --> 00:09:58,000
ಅಲ್ಲದೆ, ಅವರು ವಿಭಜನೆಯ ಯಾವುದೇ ರೀತಿಯ ಮಾಡಿ ವಶಪಡಿಸಿಕೊಳ್ಳಲು ಮಾಡಲಿಲ್ಲ.

188
00:09:58,000 --> 00:10:01,000
ಅವರು ರಿಕರ್ಶನ್ ಯಾವುದೇ ರೀತಿಯ ಕಾಣಲಿಲ್ಲ.

189
00:10:01,000 --> 00:10:03,000
ಬದಲಿಗೆ ಅವರು ಈ ರೇಖೀಯ ಅಲ್ಗಾರಿದಮ್ ಮಾಡಿದರು.

190
00:10:03,000 --> 00:10:07,000
ಆದರೆ ವೇದಿಕೆಯ ಮೇಲೆ ವಿಂಗಡಿಸುತ್ತದೆ ಸಂಖ್ಯೆಗಳ ಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸಿದಾಗ ಕಳೆದ ವಾರ ಲೈವ್

191
00:10:07,000 --> 00:10:09,000
ನಂತರ ನಾವು, ಮಧ್ಯಮ ಹೋಗುವ ಈ ಪ್ರವೃತ್ತಿ ಹೊಂದಿದ್ದರು

192
00:10:09,000 --> 00:10:13,000
ಈ ಹಂತದಲ್ಲಿ ನಾವು, ಗಾತ್ರ 4 ಅಥವಾ ಗಾತ್ರ 4 ಮತ್ತೊಂದು ಪಟ್ಟಿಯ ಒಂದು ಸಣ್ಣ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿತ್ತು

193
00:10:13,000 --> 00:10:17,000
ಮತ್ತು ನಾವು ಸರಿಯಾದ ಅದೇ ಸಮಸ್ಯೆಯನ್ನು ಹೊಂದಿತ್ತು, ಆದ್ದರಿಂದ ನಾವು ಪದೇ ಪದೇ, ಪದೇ ಪದೇ, ಪದೇ ಪದೇ.

194
00:10:17,000 --> 00:10:19,000
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾವು recursed.

195
00:10:19,000 --> 00:10:24,000
ನಮ್ಮೊಂದಿಗೆ ರಿಕರ್ಶನ್ ನಿರೂಪಿಸಲು ಇಲ್ಲಿ ನಮ್ಮ 3 ಸ್ವಯಂಸೇವಕರು ಗೆ ತುಂಬಾ ಧನ್ಯವಾದಗಳು.

196
00:10:24,000 --> 00:10:28,000
>> ನಾವು ಈಗ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಕಾಂಕ್ರೀಟ್ ಈ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನೋಡೋಣ,

197
00:10:28,000 --> 00:10:30,000
ಮತ್ತೆ ನಾವು ಬಹಳ ಸುಲಭವಾಗಿ ಮಾಡಬಹುದಾದ ಒಂದು ಸಮಸ್ಯೆ

198
00:10:30,000 --> 00:10:34,000
ಆದರೆ ನಾವು ಈ ಮೂಲ ಕಲ್ಪನೆ ಅನುಷ್ಠಾನಕ್ಕೆ ಒಂದು ಮೆಟ್ಟಿಲೆಂದು ಅದನ್ನು ಬಳಸಿ.

199
00:10:34,000 --> 00:10:37,000
ನಾನು, ಸಂಖ್ಯೆಗಳ ಒಂದು ಗುಂಪೇ ಸಂಕಲನ ಲೆಕ್ಕಾಚಾರ ಬಯಸಿದರೆ

200
00:10:37,000 --> 00:10:39,000
ಉದಾಹರಣೆಗೆ, ನೀವು ಸಂಖ್ಯೆ 3 ರಲ್ಲಿ ಹಾದು ವೇಳೆ,

201
00:10:39,000 --> 00:10:42,000
ನಾನು, ನೀವು ಸಿಗ್ಮಾ 3 ಮೌಲ್ಯವನ್ನು ನೀಡಲು ಬಯಸುವ

202
00:10:42,000 --> 00:10:46,000
ಆದ್ದರಿಂದ 3 ಮೊತ್ತವು + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
ನಾನು, ಉತ್ತರವು 6 ಮರಳಿ ಪಡೆಯಲು ಬಯಸುವ

204
00:10:48,000 --> 00:10:51,000
ಆದ್ದರಿಂದ ನಾವು ಈ ಸಿಗ್ಮಾ ಕಾರ್ಯವನ್ನು, ಈ ಸಂಕಲನ ಕಾರ್ಯವನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ವಿಲ್

205
00:10:51,000 --> 00:10:54,000
ಎಂದು, ಮತ್ತೆ, ಆದಾನ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು ನಂತರ ಸಂಕಲನ ಹಿಂದಿರುಗಿಸುತ್ತದೆ

206
00:10:54,000 --> 00:10:57,000
ಕೆಳಗೆ 0 ಆ ಸಂಖ್ಯೆಯ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ.

207
00:10:57,000 --> 00:10:59,000
ನಾವು, ಸಾಕಷ್ಟು ಸರಳವಾಗಿ ಈ ಮಾಡಬಲ್ಲರು?

208
00:10:59,000 --> 00:11:01,000
ನಾವು, ಆವರ್ತಿಸುವ ರಚನೆ ರೀತಿಯ ಈ ಇಲ್ಲ

209
00:11:01,000 --> 00:11:04,000
ಆದ್ದರಿಂದ ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಪ್ರಾರಂಭಿಸಲು ಅವಕಾಶ.

210
00:11:04,000 --> 00:11:07,000
>> Stdio.h ಸೇರಿಸಿ.

211
00:11:07,000 --> 00:11:09,000
ಇಲ್ಲಿ ಕೆಲಸ ನನ್ನನ್ನು ಮುಖ್ಯ ಆಗಿ ನನ್ನ ತಿಳಿದುಕೊಳ್ಳೋಣ.

212
00:11:09,000 --> 00:11:12,000
ಲೆಟ್ಸ್ sigma.c ಈ ಉಳಿಸಲು.

213
00:11:12,000 --> 00:11:14,000
ನಂತರ ನಾನು ಇಲ್ಲಿ ಹೋಗುತ್ತಿದ್ದೇವೆ, ಮತ್ತು ನಾನು, ಒಂದು int N ಘೋಷಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

214
00:11:14,000 --> 00:11:18,000
ಮತ್ತು ನಾನು ಬಳಕೆದಾರ ಸಹಕಾರ ಬೀರದಿದ್ದರೂ ಕೆಳಗಿನ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

215
00:11:18,000 --> 00:11:22,000
ಬಳಕೆದಾರ ಅಂತ ಧನಾತ್ಮಕ ಸಂಖ್ಯೆ ನೀಡಿಲ್ಲ ಆದರೆ

216
00:11:22,000 --> 00:11:26,000
ನನಗೆ ಮುಂದುವರಿಯಲು ಮತ್ತು n = GetInt ಅವುಗಳನ್ನು ಮಾಡುವಂತೆ ತಿಳಿಸಿ,

217
00:11:26,000 --> 00:11:28,000
ಮತ್ತು, ನಾನು ಏನು ಮಾಡಬೇಕೆಂದು ಕೆಲವು ಸೂಚನೆಗಳನ್ನು ನೀಡಲು ಅವಕಾಶ

218
00:11:28,000 --> 00:11:33,000
ಆದ್ದರಿಂದ printf ("ಪೂರ್ಣಸಂಖ್ಯೆ ದಯವಿಟ್ಟು").

219
00:11:33,000 --> 00:11:39,000
ನಾವು ಲೈನ್ 14 ಹಿಟ್ ಆದ್ದರಿಂದ ಈ ರೀತಿಯ ತುಲನಾತ್ಮಕವಾಗಿ ಸರಳವಾದ ಕೇವಲ ಏನೋ

220
00:11:39,000 --> 00:11:42,000
ನಾವು ಈಗ N ಬಹುಶಃ ಧನಾತ್ಮಕ ಪೂರ್ಣಸಂಖ್ಯೆ ಹೊಂದಿರುತ್ತವೆ.

221
00:11:42,000 --> 00:11:44,000
>> ಈಗ ಅದನ್ನು ಏನಾದರೂ ಮಾಡೋಣ.

222
00:11:44,000 --> 00:11:50,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಸಂಕಲನ ಲೆಕ್ಕಾಚಾರ ಲೆಟ್, ಆದ್ದರಿಂದ ಇಂಟ್ ಮೊತ್ತ = ಸಿಗ್ಮಾ (N).

223
00:11:50,000 --> 00:11:54,000
ಸಿಗ್ಮಾ ಕೇವಲ ಸಂಕಲನ, ಆದ್ದರಿಂದ ನಾನು ರಸಿಕ ರೀತಿಯಲ್ಲಿ ಇದನ್ನು ಬರೆಯುತ್ತಿದ್ದೇನೆ.

224
00:11:54,000 --> 00:11:56,000
ನಾವು ಅದನ್ನು ಸಿಗ್ಮಾ ಕರೆ ಮಾಡುತ್ತೇವೆ.

225
00:11:56,000 --> 00:11:58,000
ಆ ಮೊತ್ತವು, ಮತ್ತು ಈಗ ನಾನು, ಪರಿಣಾಮವಾಗಿ ಮುದ್ರಿಸುತ್ತದೆ ಪಡೆಯಲಿದ್ದೇನೆ

226
00:11:58,000 --> 00:12:08,000
printf (ಮೊತ್ತವು "ಮೊತ್ತವು D, \ n% ಆಗಿದೆ").

227
00:12:08,000 --> 00:12:11,000
ತದನಂತರ ನಾನು ಒಳ್ಳೆಯ ಅಳತೆ 0 ಬರುತ್ತೇವೆ.

228
00:12:11,000 --> 00:12:15,000
ನಾವು, ಆಸಕ್ತಿದಾಯಕ ಭಾಗ ಹೊರತುಪಡಿಸಿ ಈ ಪ್ರೋಗ್ರಾಂ ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಮಾಡಿದ

229
00:12:15,000 --> 00:12:18,000
ಇದು ವಾಸ್ತವವಾಗಿ ಸಿಗ್ಮಾ ಕಾರ್ಯವನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ತರುವುದಾಗಿದೆ.

230
00:12:18,000 --> 00:12:22,000
>> ನನ್ನ ಕೆಳಗೆ ಇಲ್ಲಿ ಕೆಳಗೆ ಹೋಗಿ, ಮತ್ತು ನನಗೆ ಕಾರ್ಯ ಸಿಗ್ಮಾ ಘೋಷಿಸಲು ಬಿಡೋಣ.

231
00:12:22,000 --> 00:12:26,000
ಇದು ರೀತಿಯ ಪೂರ್ಣಾಂಕದ ಎಂದು ಒಂದು ವೇರಿಯೇಬಲ್ ತೆಗೆದುಕೊಳ್ಳಲು ಅವರಲ್ಲಿದೆ

232
00:12:26,000 --> 00:12:30,000
ಮತ್ತು ಯಾವ ಡೇಟಾವನ್ನು ಟೈಪ್ I ಸಿಗ್ಮಾ ರಿಂದ ಸಂಭಾವ್ಯವಾಗಿ ಮರಳಲು ಬಯಸುತ್ತೀರಿ?

233
00:12:30,000 --> 00:12:34,000
ಇಂಟ್, ನಾನು ಲೈನ್ 15 ನನ್ನ ನಿರೀಕ್ಷೆಗಳನ್ನು ಹೊಂದಾಣಿಕೆ ಬಯಸುವ ಕಾರಣ.

234
00:12:34,000 --> 00:12:37,000
ಇಲ್ಲಿ ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಅನುಷ್ಠಾನಕ್ಕೆ ಅವಕಾಶ

235
00:12:37,000 --> 00:12:41,000
ಒಂದು ಸುಂದರ ಸರಳ ರೀತಿಯಲ್ಲಿ.

236
00:12:41,000 --> 00:12:45,000
>> ನ ಮುಂದೆ ಹೋಗಿ ಇಂಟ್ ಮೊತ್ತ = 0 ಹೇಳಲು ಅವಕಾಶ

237
00:12:45,000 --> 00:12:47,000
ಮತ್ತು ಈಗ ನಾನು ಇಲ್ಲಿ ಲೂಪ್ ಒಂದು ಕಡಿಮೆ ಹೋಗಲು ಪಡೆಯಲಿದ್ದೇನೆ

238
00:12:47,000 --> 00:12:50,000
ಎಂದು, ಈ ರೀತಿಯ ಹೇಳಲು ವಿಶೇಷವೇನು

239
00:12:50,000 --> 00:13:01,000
ಮೊತ್ತವು + = ನಾನು (;; ನಾನು <= ಸಂಖ್ಯೆ ನಾನು + + ಇಂಟ್ ನಾನು = 0).

240
00:13:01,000 --> 00:13:05,000
ತದನಂತರ ನಾನು ಮೊತ್ತವು ಮರಳಿ ಪಡೆಯಲಿದ್ದೇನೆ.

241
00:13:05,000 --> 00:13:07,000
ನಾನು ಎಷ್ಟೇ ಸಂಖ್ಯೆಯ ವಿಧಾನಗಳಲ್ಲಿ ಈ ಅಳವಡಿಸಿವೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

242
00:13:07,000 --> 00:13:09,000
ನಾನು ಸ್ವಲ್ಪ ಲೂಪ್ ಬಳಸಿದ್ದಾರೆ ಎಂದು.

243
00:13:09,000 --> 00:13:11,000
ನಾನು ನಿಜವಾಗಿಯೂ ಬಯಸಿದರೆ ಮೊತ್ತವು ವೇರಿಯಬಲ್ ಬಳಸಿಕೊಂಡು ಬಿಟ್ಟುಬಿಡಲಾಗಿದೆ ಇರಬಹುದು

244
00:13:11,000 --> 00:13:15,000
ಆದರೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ನಾವು ನಾನು ಮಾಡದಿದ್ದರೆ ಪೆದ್ದ ಮೊತ್ತವು 0 ಘೋಷಿಸುತ್ತದೆ ಒಂದು ಫಂಕ್ಷನ್.

245
00:13:15,000 --> 00:13:18,000
ನಂತರ, ಸಂಖ್ಯೆ ಮೂಲಕ ಅಪ್ ಮೇಲೆ 0 ರಿಂದ iterates

246
00:13:18,000 --> 00:13:23,000
ಮತ್ತು ಪ್ರತಿ ಪುನರಾವರ್ತನೆ ಅದನ್ನು ಮೊತ್ತಕ್ಕೆ ಪ್ರಸ್ತುತ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಮೊತ್ತ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

247
00:13:23,000 --> 00:13:25,000
>> ಈಗ, ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಆಪ್ಟಿಮೈಜೇಷನ್ ಇಲ್ಲ.

248
00:13:25,000 --> 00:13:29,000
ಬಹುಶಃ ಒಂದು ವ್ಯರ್ಥ ಹಂತ, ಹಾಗೆ ಅದು. ಈಗ ಆ ದಂಡವನ್ನು ಇಲ್ಲಿದೆ.

249
00:13:29,000 --> 00:13:32,000
ನಾವು ಕನಿಷ್ಠ ನೀವು ಸಂಪೂರ್ಣ ಹಾಗೂ ಅಪ್ ಮೇಲೆ 0 ಹೋಗುವುದನ್ನು.

250
00:13:32,000 --> 00:13:34,000
ತುಂಬಾ ಹಾರ್ಡ್ ಮತ್ತು ಬಹಳ ಸರಳವಾಗಿ,

251
00:13:34,000 --> 00:13:37,000
ಆದರೆ ಸಿಗ್ಮಾ ಕಾರ್ಯದಲ್ಲಿ ನಾವು ಒಂದೇ ಅವಕಾಶ ಎಂದು ತಿರುಗಿದರೆ

252
00:13:37,000 --> 00:13:39,000
ನಾವು ವೇದಿಕೆಯ ಮೇಲೆ ಇಲ್ಲಿ ಮಾಡಿದಂತೆ.

253
00:13:39,000 --> 00:13:42,000
ವೇದಿಕೆಯ ಮೇಲೆ ನಾವು, ನನಗೆ ಮುಂದಿನ ಎಂದು ಎಷ್ಟು ಜನರನ್ನು ಗಣನೆಗೆ

254
00:13:42,000 --> 00:13:47,000
ಬದಲಿಗೆ ನಾವು ಸಂಖ್ಯೆ 3 + 2 + 1 ಎಣಿಕೆ ಬಯಸಿದರೆ

255
00:13:47,000 --> 00:13:51,000
ಕೆಳಗೆ 0 ನಾವು ಒಂದು ಕಾರ್ಯ ರೀತಿಯಲ್ಲಿ ಓಡ ಸಾಧ್ಯವೋ

256
00:13:51,000 --> 00:13:55,000
ನಾನು ಬದಲಿಗೆ ಪುನರಾವರ್ತಿತ ಎಂದು ವಿವರಿಸಲು ಮಾಡುತ್ತೇವೆ ಎಂದು.

257
00:13:55,000 --> 00:13:57,000
ಇಲ್ಲಿ ನ ತ್ವರಿತ ವಿವೇಕ ಪರಿಶೀಲಿಸಿ ಮತ್ತು ನಾನು ಪೆದ್ದ ಮಾಡಲಿಲ್ಲ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮಾಡೋಣವೇ.

258
00:13:57,000 --> 00:14:00,000
>> ನಾನು ತಪ್ಪು ಮಾಡಿದಿರಿ ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಕನಿಷ್ಠ ಒಂದು ಹೆಜ್ಜಿಯಿಲ್ಲ ತಿಳಿದಿದೆ.

259
00:14:00,000 --> 00:14:04,000
ನಾನು ನಮೂದಿಸಿ ಹೊಡೆದಾಗ ನಾನು ನನಗೆ ಚೀರುತ್ತಾ ಹಾರಿದಂತೆ ಯಾವುದೇ ರೀತಿಯ ಪಡೆಯಲು ಹೋಗುತ್ತಿದ್ದೇನೆ?

260
00:14:04,000 --> 00:14:06,000
ನಾನು ಬಗ್ಗೆ ಕೂಗಿ ಮಾಡಲು ಏನು ನಾನು?

261
00:14:06,000 --> 00:14:11,000
ಹೌದು, ನಾನು ಮಾದರಿ ಮರೆತುಹೋಗಿದೆ,, ನಾನು ಲೈನ್ 15 ರಂದು ಸಿಗ್ಮಾ ಎಂಬ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ನಾನು ಹಾಗೆ

262
00:14:11,000 --> 00:14:16,000
ಆದರೆ ಸಾಲು 22 ರವರೆಗೆ ಡಿಕ್ಲೇರ್ಡ್, ಆದ್ದರಿಂದ ನಾನು ಅತ್ಯುತ್ತಮ ಪೂರ್ವನಿಯಾಮಕವಾಗಿ ಇಲ್ಲಿ ಹೋಗಿ ದೊರೆಯದಿದ್ದಲ್ಲಿ

263
00:14:16,000 --> 00:14:22,000
ಮತ್ತು ಒಂದು ಮಾದರಿ ಘೋಷಿಸಿದ, ಮತ್ತು ನಾನು ಇಂಟ್ ಸಿಗ್ಮಾ (ಇಂಟ್ ಸಂಖ್ಯೆ) ಹೇಳುತ್ತೇನೆ, ಮತ್ತು ಅಷ್ಟೇ.

264
00:14:22,000 --> 00:14:24,000
ಇದು ಕೆಳಭಾಗದಲ್ಲಿ ಜಾರಿಗೆ ನ.

265
00:14:24,000 --> 00:14:27,000
>> ಅಥವಾ ಈ ಪರಿಹರಿಸಿಕೊಳ್ಳಬಹುದು ಮತ್ತೊಂದು ರೀತಿಯಲ್ಲಿ,

266
00:14:27,000 --> 00:14:30,000
ನಾನು, ಇದು ಕೆಟ್ಟ ಅಲ್ಲ, ಅಲ್ಲಿ ಅಪ್ ಕಾರ್ಯ ಸ್ಥಳಾಂತರ

267
00:14:30,000 --> 00:14:32,000
ಆದರೆ ಕನಿಷ್ಠ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು, ನಾನೂ, ದೀರ್ಘ ಪಡೆಯಲು ಪ್ರಾರಂಭಿಸಿದಾಗ

268
00:14:32,000 --> 00:14:35,000
ನಾನು ಯಾವಾಗಲೂ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಮುಖ್ಯ ಹೊಂದಿರುವ ಕೆಲವು ಮೌಲ್ಯವಿದೆ ಹಿತ

269
00:14:35,000 --> 00:14:38,000
ನೀವು ರೀಡರ್ ಕಡತವನ್ನು ತೆರೆಯಲು ತದನಂತರ ತಕ್ಷಣವೇ ನೋಡಬಹುದು ಆದ್ದರಿಂದ

270
00:14:38,000 --> 00:14:40,000
ಪ್ರೋಗ್ರಾಂ ಮೂಲಕ ಹುಡುಕಲು ಮಾಡದೆಯೇ ಮಾಡುತ್ತಿರುವ

271
00:14:40,000 --> 00:14:42,000
ಪ್ರಮುಖ ಕಾರ್ಯ ಹುಡುಕುತ್ತಿರುವ.

272
00:14:42,000 --> 00:14:49,000
ನ ಇಲ್ಲಿ ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಕೆಳಗೆ ಹೋಗಿ ನೋಡೋಣ, ಸಿಗ್ಮಾ ಸಿಗ್ಮಾ ಮಾಡಲು ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ

273
00:14:49,000 --> 00:14:51,000
ನಾನು ತುಂಬಾ ಇಲ್ಲಿ ಸ್ಕ್ರೆವೆದ್.

274
00:14:51,000 --> 00:14:55,000
ಕಾರ್ಯ GetInt ಸೂಚ್ಯ ಘೋಷಣೆ ನಾನು ಇನ್ನೇನು ಮಾಡಲು ಮರೆತು ನಾವು ಅರ್ಥ?

275
00:14:55,000 --> 00:14:57,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

276
00:14:57,000 --> 00:15:00,000
ಗುಡ್, ಆದ್ದರಿಂದ ಸ್ಪಷ್ಟವಾಗಿ ಒಂದು ಸಾಮಾನ್ಯ ತಪ್ಪು, ಆದ್ದರಿಂದ, ನ ಇಲ್ಲಿ ಈ ಅವಕಾಶ ಅವಕಾಶ

277
00:15:00,000 --> 00:15:04,000
cs50.h, ಮತ್ತು ಈಗ ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಹಿಂತಿರುಗಿ ಅವಕಾಶ.

278
00:15:04,000 --> 00:15:08,000
>> ನಾನು ಪರದೆಯ ತೆರವುಗೊಳಿಸಿ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಸಿಗ್ಮಾ ಮಾಡಲು ಮರುಪ್ರದರ್ಶನ ಮಾಡುತ್ತೇವೆ.

279
00:15:08,000 --> 00:15:11,000
ಇದು ಕಂಪೈಲ್ ತೋರುತ್ತದೆ. ನನಗೆ ಈಗ ಸಿಗ್ಮಾ ಔಟ್ ಲೆಟ್.

280
00:15:11,000 --> 00:15:15,000
ನಾನು ಸಂಖ್ಯೆ 3 ಟೈಪ್ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ನಾನು 6 ಬಂದೆವು, ಆದ್ದರಿಂದ ಒಂದು ಕಠಿಣ ಚೆಕ್

281
00:15:15,000 --> 00:15:18,000
ಆದರೆ ಕನಿಷ್ಠ, ಅದು ಮೊದಲ ನೋಟದಲ್ಲಿ ಕೆಲಸ ಕಾಣುತ್ತದೆ, ಆದರೆ ಈಗ ನಾವು ಇದನ್ನು ಹೊರತುಪಡಿಸಿ ನಕಲು ಮಾಡ

282
00:15:18,000 --> 00:15:21,000
ಮತ್ತು ಈಗ ವಾಸ್ತವವಾಗಿ, ಮತ್ತೆ, ರಿಕರ್ಶನ್ ಕಲ್ಪನೆಯನ್ನು ಹತೋಟಿ

283
00:15:21,000 --> 00:15:24,000
ಒಂದು ಸರಳ ಸಂದರ್ಭದಲ್ಲಿ ಆದ್ದರಿಂದ ಕೆಲವು ವಾರಗಳ 'ಸಮಯದಲ್ಲಿ

284
00:15:24,000 --> 00:15:27,000
ನಾವು ರಚನೆಗಳು ಹೆಚ್ಚು ಆಸಕ್ತ ಅಕ್ಷಾಂಶ ರಚನೆಗಳು ಅನ್ವೇಷಿಸುವ ಪ್ರಾರಂಭಿಸಿದಾಗ

285
00:15:27,000 --> 00:15:30,000
ನಾವು ಯಾವ ಜೊತೆ ಟೂಲ್ಕಿಟ್ ಮತ್ತೊಂದು ಸಾಧನದ

286
00:15:30,000 --> 00:15:33,000
ನಾವು ನೋಡುತ್ತಾರೆ ಎಂದು ಆ ಡೇಟಾವನ್ನು ರಚನೆಗಳು ಕುಶಲತೆಯಿಂದ.

287
00:15:33,000 --> 00:15:36,000
ಈ ರೋಗ ವಿಧಾನ, ಲೂಪ್ ಆಧಾರಿತ ವಿಧಾನವಾಗಿದೆ.

288
00:15:36,000 --> 00:15:39,000
>> ಈಗ ಇದನ್ನು ಬದಲಾಗಿ ನನಗೆ ತಿಳಿಸಿ.

289
00:15:39,000 --> 00:15:44,000
ಬದಲಾಗಿ ಹೇಳಲು ನನಗೆ ಅವಕಾಶ ಆ ಸಂಖ್ಯೆಯ ಸಂಕಲನ

290
00:15:44,000 --> 00:15:48,000
ನಿಜವಾಗಿಯೂ ಅದೇ ವಿಷಯ 0 ಕೆಳಗೆ ಮೇಲೆ

291
00:15:48,000 --> 00:15:53,000
ಸಂಖ್ಯೆ + ಸಿಗ್ಮಾ (ಸಂಖ್ಯೆ - 1).

292
00:15:53,000 --> 00:15:57,000
ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಕೇವಲ ವೇದಿಕೆಯಲ್ಲಿ ರೀತಿಯಲ್ಲಿ ನಾನು, ನನಗೆ ಮುಂದಿನ ಜನರು ಪ್ರತಿಯೊಂದು punted

293
00:15:57,000 --> 00:16:00,000
ಇದಕ್ಕೆ ಪ್ರತಿಯಾಗಿ, ನಾವು ಅಂತಿಮವಾಗಿ ವಿಲ್ಲಿ ಹೊರಗೆ ಕೆಳಗೆ ರವರೆಗೆ ವಿಶಿಷ್ಟ ಗುರುತನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ

294
00:16:00,000 --> 00:16:03,000
ಇವರು 0 ಒಂದು ಹಾರ್ಡ್ ಕೋಡೆಡ್ ಉತ್ತರವನ್ನು ಮರಳಬೇಕಾಯಿತು.

295
00:16:03,000 --> 00:16:07,000
ಇಲ್ಲಿ ಈಗ ನಾವು ಇದೇ ಸಿಗ್ಮಾ ಗೆ ವಿಶಿಷ್ಟ ಗುರುತನ್ನು ನೀವು

296
00:16:07,000 --> 00:16:10,000
ಅದೇ ಕಾರ್ಯ ಎಂದು ಕರೆಯಲಾಗುತ್ತಿತ್ತು, ಆದರೆ ಪ್ರಮುಖ ಒಳನೋಟವನ್ನು ಇಲ್ಲಿ ಮಾಡಲಾಯಿತು

297
00:16:10,000 --> 00:16:12,000
ನಾವು ಒಂದೇ ಸಿಗ್ಮಾ ಕರೆ ಇಲ್ಲ ಎಂಬುದು.

298
00:16:12,000 --> 00:16:14,000
ನಾವು N ಸಾಗುವ ಇಲ್ಲ.

299
00:16:14,000 --> 00:16:17,000
ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಸಂಖ್ಯೆಯಲ್ಲಿ ಹಾದುಹೋಗುವ ನೀವು - 1,

300
00:16:17,000 --> 00:16:20,000
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ಸಣ್ಣ ಸಮಸ್ಯೆ, ಸ್ವಲ್ಪ ಸಣ್ಣ ಸಮಸ್ಯೆ.

301
00:16:20,000 --> 00:16:23,000
>> ದುರದೃಷ್ಟವಶಾತ್, ಈ ಇನ್ನೂ ಸಾಕಷ್ಟು ಪರಿಹಾರ ಅಲ್ಲ, ಮತ್ತು ನಾವು ಸರಿಪಡಿಸಲು ಮೊದಲು

302
00:16:23,000 --> 00:16:26,000
ನಿಮ್ಮ ಕೆಲವು ಸ್ಪಷ್ಟ ಮಾಹಿತಿ ಏನೆಂದು ಜಿಗಿತದ ಇರಬಹುದು

303
00:16:26,000 --> 00:16:28,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಮಾಡಲು ಮರುಪ್ರದರ್ಶನ ಅವಕಾಶ.

304
00:16:28,000 --> 00:16:30,000
ಪರವಾಗಿಲ್ಲ ಕಂಪೈಲ್ ತೋರುತ್ತದೆ.

305
00:16:30,000 --> 00:16:32,000
ನನಗೆ 6 ಜೊತೆ ಸಿಗ್ಮಾ ಮರುಪ್ರದರ್ಶನ ಲೆಟ್.

306
00:16:32,000 --> 00:16:37,000
ಓಹ್, ನನಗೆ 6 ಜೊತೆ ಸಿಗ್ಮಾ ಮರುಪ್ರದರ್ಶನ ಅವಕಾಶ.

307
00:16:37,000 --> 00:16:42,000
ನಾವು ಹಾಗೆಯೇ ಆಕಸ್ಮಿಕವಾಗಿ ಕೊನೆಯ ಬಾರಿಗೆ ಆದರೂ, ಮೊದಲು ಈ ನೋಡಿದ್ದೇವೆ.

308
00:16:42,000 --> 00:16:48,000
ನಾನು ಈ ರಹಸ್ಯ ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಬಂದೆವು? ಹೌದು.

309
00:16:48,000 --> 00:16:50,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

310
00:16:50,000 --> 00:16:53,000
ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ ಯಾವುದೇ ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ, ಮತ್ತು, ಬಹುಶಃ ಏನು ಸಂಭವಿಸಿತು?

311
00:16:53,000 --> 00:16:58,000
ಈ ಯಾವ ವರ್ತನೆಯ ಲಕ್ಷಣ?

312
00:16:58,000 --> 00:17:00,000
ಸ್ವಲ್ಪ ಜೋರಾಗಿ ಹೇಳುವೆನು.

313
00:17:00,000 --> 00:17:02,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

314
00:17:02,000 --> 00:17:05,000
ಇದು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಅನಂತ ಆದೇಶಗಳ, ಮತ್ತು ಅನಂತ ಆವರ್ತನೆಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ಸಮಸ್ಯೆ

315
00:17:05,000 --> 00:17:08,000
ಅವರು ಈ ಸಂದರ್ಭದಲ್ಲಿ ರಿಕರ್ಶನ್ ಒಳಗೊಂಡಿರುತ್ತವೆ ಮಾಡಿದಾಗ, ಒಂದು ಕ್ರಿಯೆ, ಸ್ವತಃ ಕರೆ

316
00:17:08,000 --> 00:17:10,000
ನಿಮಗೆ ಒಂದು ಕಾರ್ಯವನ್ನು ಕರೆ ಪ್ರತಿ ಬಾರಿ ಏನಾಗುತ್ತದೆ?

317
00:17:10,000 --> 00:17:13,000
ಹಾಗೆಯೇ, ನಾವು ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿ ಔಟ್ ಹಾಕಿತು ಹೇಗೆ ಮರಳಿ ಭಾವಿಸುತ್ತೇನೆ.

318
00:17:13,000 --> 00:17:16,000
ನಾವು, ಕೆಳಭಾಗದಲ್ಲಿ ಎಂದು ಸ್ಟಾಕ್ ಎಂಬ ಮೆಮೊರಿ ಈ ಪಡೆ ಇಲ್ಲ ಎಂದು

319
00:17:16,000 --> 00:17:19,000
ಮತ್ತು ನೀವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಮೆಮೊರಿ ಒಂದು ಫಂಕ್ಷನ್ ಕಾಲ್ ಪ್ರತಿ ಬಾರಿ ಪುಟ್ ಮುಟ್ಟುತ್ತದೆ

320
00:17:19,000 --> 00:17:24,000
ಆ ಕಾರ್ಯವನ್ನು ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಅಥವಾ ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿರುವ ಈ ಕರೆಯಲ್ಪಡುವ ಸ್ಟಾಕ್ ಮೇಲೆ,

321
00:17:24,000 --> 00:17:27,000
ಸಿಗ್ಮಾ ಸಿಗ್ಮಾ ಕರೆಗಳು ಕರೆಗಳನ್ನು ಹಾಗಾಗಿ ಸಿಗ್ಮಾ ಸಿಗ್ಮಾ ಕರೆಗಳು

322
00:17:27,000 --> 00:17:29,000
 ಸಿಗ್ಮಾ ಕರೆಗಳನ್ನು ಅಲ್ಲಿ ಈ ಕಥೆ ಕೊನೆಯಲ್ಲಿ ಮಾಡುತ್ತದೆ?

323
00:17:29,000 --> 00:17:31,000
>> ಅಲ್ಲದೆ, ಅಂತಿಮವಾಗಿ ಅತಿಕ್ರಮಣವನ್ನು ಒಟ್ಟು

324
00:17:31,000 --> 00:17:33,000
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ಗೆ ಲಭ್ಯವಿದೆ ಎಂದು ಮೆಮೊರಿಯ.

325
00:17:33,000 --> 00:17:37,000
ನೀವು ಒಳಗೆ ಭಾವಿಸಲಾಗಿದೆ ನೀವು ವಿಭಾಗದಲ್ಲಿ, ತುಂಬಿರುವುದರಿಂದ

326
00:17:37,000 --> 00:17:40,000
ಮತ್ತು ನೀವು ಈ ವಿಭಜನೆ ತಪ್ಪು ಪಡೆಯಲು, ಕೋರ್, ಸುರಿಸಿದ

327
00:17:40,000 --> 00:17:43,000
ಮತ್ತು ಸುರಿಸಿದ ಏನು ಕೋರ್ ಎಂದರೆ ಈಗ ಕೋರ್ ಎಂಬ ಕಡತ ಹೊಂದಿರುತ್ತವೆ

328
00:17:43,000 --> 00:17:46,000
ಇದು ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಹೊಂದಿರುವ ಒಂದು ಕಡತವಾಗಿರುತ್ತದೆ

329
00:17:46,000 --> 00:17:49,000
ಎಂದು ವಾಸ್ತವವಾಗಿ ಭವಿಷ್ಯದಲ್ಲಿ ವಿಶ್ಲೇಷಣಾತ್ಮಕವಾಗಿ ಉಪಯುಕ್ತ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

330
00:17:49,000 --> 00:17:52,000
ನಿಮ್ಮ ದೋಷವನ್ನು ಅಲ್ಲಿ ನೀವು ಸ್ಪಷ್ಟ ಅಲ್ಲ ವೇಳೆ

331
00:17:52,000 --> 00:17:54,000
ನಿಜವಾಗಿಯೂ, ಆದ್ದರಿಂದ ಮಾತನಾಡಲು, ನ್ಯಾಯ ವಿಶ್ಲೇಷಣೆಯ ಒಂದು ಬಿಟ್ ಮಾಡಬಹುದು

332
00:17:54,000 --> 00:17:58,000
ಈ ಕೋರ್ ಡಂಪ್ ಫೈಲ್ನಲ್ಲಿ, ಇದು ಮತ್ತೊಮ್ಮೆ, ಕೇವಲ ಸೊನ್ನೆಗಳು ಮತ್ತು ಚಿತ್ರಗಳ ಒಂದು ಸಂಪೂರ್ಣ ಗುಂಪೇ ಆಗಿದೆ

333
00:17:58,000 --> 00:18:02,000
ಆ ಮೂಲಭೂತವಾಗಿ ಮೆಮೊರಿ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ರಾಜ್ಯ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

334
00:18:02,000 --> 00:18:05,000
ಕ್ಷಣ ಈ ರೀತಿಯಲ್ಲಿ ಅಪ್ಪಳಿಸಿತು.

335
00:18:05,000 --> 00:18:11,000
>> ಇಲ್ಲಿ ಸರಿಪಡಿಸಲು ನಾವು ಕುರುಡಾಗಿ, ಸಿಗ್ಮಾ ಹಿಂತಿರುಗಿಸಿಲ್ಲ ಮಾಡುತ್ತದೆ

336
00:18:11,000 --> 00:18:14,000
ಸಂಖ್ಯೆ + ಸ್ವಲ್ಪ ಸಣ್ಣ ಸಮಸ್ಯೆ ಸಿಗ್ಮಾ.

337
00:18:14,000 --> 00:18:16,000
ನಾವು ಇಲ್ಲಿ ಬೇಸ್ ಪ್ರಕರಣದ ರೀತಿಯ ಮಾಡಬೇಕು

338
00:18:16,000 --> 00:18:19,000
ಮತ್ತು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಬಹುಶಃ ಏನು ಮಾಡಬೇಕು?

339
00:18:19,000 --> 00:18:22,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

340
00:18:22,000 --> 00:18:25,000
ಸರಿ, ಬಹಳ ಸಂಖ್ಯೆಯ ಧನಾತ್ಮಕ ಎಂದು ನಾವು ವಾಸ್ತವವಾಗಿ, ಈ ಹಿಂದಿರುಗಬೇಕೆಂದು

341
00:18:25,000 --> 00:18:29,000
ಅಥವಾ ಇನ್ನೊಂದು ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಸಂಖ್ಯೆ ವೇಳೆ, ಸೇ, <= 0

342
00:18:29,000 --> 00:18:32,000
ನೀವು, ನಾನು ಮುಂದೆ ಹೋಗಿ 0 ಬರುತ್ತೇವೆ ಎಂಬುದನ್ನು ತಿಳಿಯಲು

343
00:18:32,000 --> 00:18:36,000
ವಿಲ್ಲಿ ಮಾಡಿದರು ಹೆಚ್ಚಿನ ರೀತಿಯಲ್ಲಿ, ಮತ್ತು ಬೇರೆ, ನಾನು ಮುಂದುವರಿಯಲು ಪಡೆಯಲಿದ್ದೇನೆ

344
00:18:36,000 --> 00:18:41,000
ಮತ್ತು ಈ ಮರಳಿ, ಆದ್ದರಿಂದ ಇದು ಕಡಿಮೆ ಅಲ್ಲ

345
00:18:41,000 --> 00:18:44,000
ನಾವು ಮೊದಲ ಲೂಪ್ ಒಂದು ಬಳಸಿಕೊಂಡು ಅಪ್ ಹಾಲಿನ ಎಂದು ರೋಗ ಆವೃತ್ತಿ ಹೆಚ್ಚು,

346
00:18:44,000 --> 00:18:48,000
ಆದರೆ ಅದರ ಸೊಬಗು ಈ ರೀತಿಯ ಇಲ್ಲ ಎಂದು ಗಮನಿಸುವುದಿಲ್ಲ.

347
00:18:48,000 --> 00:18:51,000
ಬದಲಾಗಿ ಕೆಲವು ಸಂಖ್ಯೆಯ ಹಿಂದಿರುಗಿದ ಮತ್ತು ಈ ಗಣಿತ ಪ್ರದರ್ಶನ

348
00:18:51,000 --> 00:18:54,000
ಮತ್ತು ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಕೆಲಸಗಳನ್ನು ಅಪ್ ಸೇರಿಸುವ

349
00:18:54,000 --> 00:18:57,000
ನೀವು ಬದಲಿಗೆ ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು "ಸರಿ, ಈ ಒಂದು ಸೂಪರ್ ಸುಲಭ ಸಮಸ್ಯೆ ವೇಳೆ,

350
00:18:57,000 --> 00:19:01,000
ಸಂಖ್ಯೆ <0 ಹಾಗೆ, ನನಗೆ ತಕ್ಷಣ 0 ಹಿಂದಿರುಗಲು ಅವಕಾಶ. "

351
00:19:01,000 --> 00:19:03,000
>> ನಾವು, ಪೋಷಕ ಋಣಾತ್ಮಕ ಸಂಖ್ಯೆಗಳ ಚಿಂತೆ ಉಂಟುಮಾಡಿದಂತೆ ಹೋಗುತ್ತಿಲ್ಲ

352
00:19:03,000 --> 00:19:05,000
ಆದ್ದರಿಂದ ನಾನು ಹಾರ್ಡ್ ಕೋಡ್ 0 ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ.

353
00:19:05,000 --> 00:19:08,000
ಆದರೆ ಮೇಲಿಂಗ್ ಕೂಡಿಸಿ ಈ ವಿಚಾರವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು

354
00:19:08,000 --> 00:19:11,000
ಈ ಸಂಖ್ಯೆಗಳ ಎಲ್ಲಾ ಒಟ್ಟಿಗೆ ನೀವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಸಣ್ಣ ಬೈಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು

355
00:19:11,000 --> 00:19:14,000
ಸಮಸ್ಯೆಯ ಔಟ್, ಹೆಚ್ಚಿನ ರೀತಿಯಲ್ಲಿ ನಾವು, ವೇದಿಕೆಯಲ್ಲಿ ಇಲ್ಲಿ ಮಾಡಿದರು

356
00:19:14,000 --> 00:19:18,000
ನಂತರ ಓಡ ಮುಂದಿನ ವ್ಯಕ್ತಿಗೆ ಸಮಸ್ಯೆ ಉಳಿದ,

357
00:19:18,000 --> 00:19:20,000
ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮುಂದಿನ ವ್ಯಕ್ತಿಯು ನಿಮ್ಮನ್ನು ಹೊಂದಿದೆ.

358
00:19:20,000 --> 00:19:22,000
ಇದು ಒಂದೇ ಹೆಸರಿನ ಕಾರ್ಯ ನ.

359
00:19:22,000 --> 00:19:25,000
ಅದನ್ನು, ಒಂದು ಸಣ್ಣ ಮತ್ತು ಸಣ್ಣ ಮತ್ತು ಸಣ್ಣ ಸಮಸ್ಯೆ ಪ್ರತಿ ಕಾಲವನ್ನು

360
00:19:25,000 --> 00:19:28,000
ನಾವು ಇಲ್ಲಿ ಕೋಡ್ ನಲ್ಲಿ ಸಾಕಷ್ಟು ರೂಪುರೇಷೆಗಳನ್ನು ವಿಷಯಗಳನ್ನು ಸಹ

361
00:19:28,000 --> 00:19:33,000
ಈ ಫೋನ್ ಪುಸ್ತಕ ವಾರ 0 ನಡೆಯುತ್ತಿರುವುದರ ನಿಖರವಾಗಿ ಏನು.

362
00:19:33,000 --> 00:19:36,000
ಈ ಸೀನ್ ಜೊತೆ ಕಳೆದ ವಾರಗಳ ನಡೆಯುತ್ತಿರುವುದರ ನಿಖರವಾಗಿ ಏನು

363
00:19:36,000 --> 00:19:39,000
ಮತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು ಹುಡುಕುವ ನಮ್ಮ ಪ್ರದರ್ಶನಗಳು ಜೊತೆ.

364
00:19:39,000 --> 00:19:42,000
ಇದು ಒಂದು ಸಮಸ್ಯೆ ತೆಗೆದುಕೊಂಡು ಮತ್ತೆ ಮತ್ತೆ ಭಾಗಿಸುವ ನ.

365
00:19:42,000 --> 00:19:44,000
>> ಅರ್ಥಾತ್, ಅನುವಾದ ಈಗ ಒಂದು ರೀತಿಯಲ್ಲಿ ಇಲ್ಲ

366
00:19:44,000 --> 00:19:47,000
ಈ ನೈಜ ರಚನೆ, ಈ ಉನ್ನತ ಮಟ್ಟದ ರಚನೆಯ

367
00:19:47,000 --> 00:19:51,000
ವಿಭಜನೆಯನ್ನು ವಶಪಡಿಸಿಕೊಳ್ಳಲು ಮತ್ತೆ ಮತ್ತೆ ಏನನ್ನಾದರೂ ಮಾಡುವ

368
00:19:51,000 --> 00:19:56,000
ಕೋಡ್ ರಲ್ಲಿ, ಆದ್ದರಿಂದ ನಾವು ಈ ಬಾರಿ ಮತ್ತೊಮ್ಮೆ ನೋಡುತ್ತಾರೆ ಸಂಗತಿಯಾಗಿದೆ.

369
00:19:56,000 --> 00:20:00,000
ನೀವು ರಿಕರ್ಶನ್ ಹೊಸ ಇಂತಹ ಈಗ ಅತ್ತ, ನೀವು ಕನಿಷ್ಠ ಈಗ ಅರ್ಥ ಬೇಕು

370
00:20:00,000 --> 00:20:02,000
ಏಕೆ ಈ ಮೋಜಿನ ಹೊಂದಿದೆ.

371
00:20:02,000 --> 00:20:05,000
ನಾನು, google.com ಗೆ ಹೋಗಲು ಪಡೆಯಲಿದ್ದೇನೆ

372
00:20:05,000 --> 00:20:17,000
ಮತ್ತು ನಾನು ರಿಕರ್ಶನ್ ಕೆಲವು ಸಲಹೆಗಳು ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಹುಡುಕಲು ಪಡೆಯಲಿದ್ದೇನೆ, ನಮೂದಿಸಿ.

373
00:20:17,000 --> 00:20:21,000
ಅವರು ಇದೀಗ ನಗುವುದು ಇಲ್ಲದ ನಿಮ್ಮ ನಂತರದ ವ್ಯಕ್ತಿಗೆ ಹೇಳಿ.

374
00:20:21,000 --> 00:20:23,000
ನೀವು ರಿಕರ್ಶನ್ ಹೇಳಿದಿರಿ?

375
00:20:23,000 --> 00:20:25,000
ನೀವು ಮಾಡಲಿಲ್ಲ ಅರ್ಥ-AH, ನಾವು ಹೋಗಿ.

376
00:20:25,000 --> 00:20:28,000
ಸರಿ, ಈಗ ಪ್ರತಿಯೊಬ್ಬರೂ ಉಳಿದ ಇಲ್ಲಿದೆ.

377
00:20:28,000 --> 00:20:30,000
ಸ್ವಲ್ಪ ಈಸ್ಟರ್ ಎಗ್ ಗೂಗಲ್ ಎಲ್ಲೋ ಅಲ್ಲಿ ಎಂಬೆಡೆಡ್.

378
00:20:30,000 --> 00:20:33,000
ಒಂದು ಪಕ್ಕಕ್ಕೆ, ನಾವು ಕೋರ್ಸ್ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಪುಟ್ ಕೊಂಡಿಗಳು ಒಂದು

379
00:20:33,000 --> 00:20:36,000
ಇಂದು ವಿವಿಧ ಬೇರ್ಪಡಿಸುವ ಕ್ರಮಾವಳಿಗಳು ಕೇವಲ ಈ ಚೌಕಟ್ಟನ್ನು ಹೊಂದಿದೆ

380
00:20:36,000 --> 00:20:39,000
ನಾವು ಕಳೆದ ವಾರ ನೋಡಿದ್ದಾರೆ, ಆದರೆ ಏನು ಈ ದೃಶ್ಯೀಕರಣ ಬಗ್ಗೆ ಸಂತೋಷವನ್ನು ಇಲ್ಲಿದೆ ಕೆಲವು

381
00:20:39,000 --> 00:20:43,000
ನೀವು ಕ್ರಮಾವಳಿಗಳು ಸಂಬಂಧಿಸಿದ ವಿವಿಧ ವಿಷಯಗಳ ಸುತ್ತ ನಿಮ್ಮ ಮನಸ್ಸನ್ನು ಕಟ್ಟಲು ಯತ್ನಿಸುವ

382
00:20:43,000 --> 00:20:46,000
ನೀವು ಅತ್ಯಂತ ಸುಲಭವಾಗಿ ಈಗ ಒಳಹರಿವಿನ ವಿವಿಧ ರೀತಿಯ ಆರಂಭಿಸಬಹುದು ತಿಳಿದಿದೆ.

383
00:20:46,000 --> 00:20:50,000
ಒಳಹರಿವು ಅಂಶಗಳು ಯಾದೃಚ್ಛಿಕ ಇತ್ಯಾದಿ, ಒಳಹರಿವು ಹೆಚ್ಚಾಗಿ ವಿಂಗಡಿಸಿ, ವ್ಯತಿರಿಕ್ತವಾಗಿದೆ.

384
00:20:50,000 --> 00:20:53,000
ನೀವು ಮತ್ತೆ ಪ್ರಯತ್ನಿಸಿ ಎಂದು, ನಿಮ್ಮ ಮನಸ್ಸಿನಲ್ಲಿ ಈ ವಿಷಯಗಳನ್ನು ವ್ಯತ್ಯಾಸ

385
00:20:53,000 --> 00:20:57,000
ಅರ್ಥವಾಗುವುದೇನೆಂದರೆ ಲೆಕ್ಚರ್ಸ್ ಪುಟದಲ್ಲಿ ಕೋರ್ಸ್ ವೆಬ್ಸೈಟ್ನಲ್ಲಿ ಈ URL

386
00:20:57,000 --> 00:21:00,000
ಆ ಕೆಲವು ಮೂಲಕ ಕಾರಣ ಸಹಾಯವಾಗಬಹುದು.

387
00:21:00,000 --> 00:21:05,000
>> ಇಂದು ನಾವು ಅಂತಿಮವಾಗಿ, ಮತ್ತೆ ಸ್ವಲ್ಪ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಪಡೆಯಿರಿ

388
00:21:05,000 --> 00:21:08,000
ಇದು ಈ ಸ್ವಾಪ್ ಕಾರ್ಯವನ್ನು ಕೇವಲ ಕೆಲಸ ಮಾಡಿದ್ದು

389
00:21:08,000 --> 00:21:12,000
ಮತ್ತು, ಈ ಕಾರ್ಯವನ್ನು ಸ್ವಾಪ್ ಮೂಲಭೂತ ಸಮಸ್ಯೆಯೆಂದರೆ ಆಗಿದ್ದದ್ದು

390
00:21:12,000 --> 00:21:15,000
ಇಲ್ಲಿ ಮತ್ತು ಇಲ್ಲಿ ಮೌಲ್ಯ ವಿನಿಮಯ, ಮತ್ತೆ, ಈ ಗೋಲು ಇದು

391
00:21:15,000 --> 00:21:17,000
ಹೀಗೆ ಇಂತಹ?

392
00:21:17,000 --> 00:21:20,000
ಈ ವಾಸ್ತವವಾಗಿ ಕೈಗೂಡಲಿಲ್ಲ. ಏಕೆ?

393
00:21:20,000 --> 00:21:22,000
ಹೌದು.

394
00:21:22,000 --> 00:21:28,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

395
00:21:28,000 --> 00:21:31,000
ಈ bugginess ಫಾರ್ ನಿಖರವಾಗಿ, ವಿವರಣೆ

396
00:21:31,000 --> 00:21:34,000
ನೀವು ಸಿ ಕಾರ್ಯಗಳನ್ನು ಕರೆ ಏಕೆಂದರೆ ಸುಮ್ಮನೆ

397
00:21:34,000 --> 00:21:38,000
ಮತ್ತು ಆ ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಮತ್ತು ಬಿ ಇಲ್ಲಿ ನಂತಹ, ವಾದಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು

398
00:21:38,000 --> 00:21:42,000
ನೀವು ಆ ಕಾರ್ಯಕ್ಕೆ ಒದಗಿಸುವ ನೀವು ಏನೇ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿಗಳನ್ನು ರಲ್ಲಿ ಹಾದು ಹೋಗುತ್ತವೆ.

399
00:21:42,000 --> 00:21:46,000
ನೀವು, ಮೂಲ ಮೌಲ್ಯಗಳನ್ನು ತಮ್ಮನ್ನು ಒದಗಿಸುವ ಇಲ್ಲ

400
00:21:46,000 --> 00:21:49,000
ಆದ್ದರಿಂದ ನಾವು, buggyc ಸಂದರ್ಭದಲ್ಲಿ ಈ ಕಂಡಿತು

401
00:21:49,000 --> 00:21:52,000
ಈ ರೀತಿ ಸ್ವಲ್ಪ ಏನಾದರೂ ಗಮನಹರಿಸಿದ್ದ buggy3.c.

402
00:21:52,000 --> 00:21:57,000
>> ನಾವು x ಮತ್ತು y ಅನುಕ್ರಮವಾಗಿ 1 ಮತ್ತು 2 ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಎಂದು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

403
00:21:57,000 --> 00:21:59,000
ನಾವು ಆಗ ಅವರು ಏನೆಂದು ಮುದ್ರಿತ.

404
00:21:59,000 --> 00:22:03,000
ನಾನು ನಂತರ ನಾನು x, y ನ ಸ್ವಾಪ್ ಕರೆದು ಅವರಿಗೆ ವಿನಿಮಯ ಹೇಳಿತು.

405
00:22:03,000 --> 00:22:06,000
ಆದರೆ ಸಮಸ್ಯೆ, ವಿನಿಮಯ ಕೆಲಸ ಎಂದು

406
00:22:06,000 --> 00:22:10,000
ಆದರೆ ಸ್ವಾಪ್ ವ್ಯಾಪ್ತಿಯ ಸ್ವತಃ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

407
00:22:10,000 --> 00:22:13,000
ನಾವು ಲೈನ್ 40 ಆ ವಿನಿಮಯವಾಗಿದೆ ಮೌಲ್ಯಗಳನ್ನು ಹಿಟ್ ತಕ್ಷಣ

408
00:22:13,000 --> 00:22:16,000
ದೂರ ಎಸೆಯಲಾಯಿತು, ಮತ್ತು ಆದ್ದರಿಂದ ಯಾವುದೇ

409
00:22:16,000 --> 00:22:21,000
ಮೂಲ ಕಾರ್ಯದಲ್ಲಿ ಮುಖ್ಯ ವಾಸ್ತವವಾಗಿ, ಎಲ್ಲ ಬದಲಾಯಿತು

410
00:22:21,000 --> 00:22:26,000
ಈ ನಮ್ಮ ಮೆಮೊರಿ ಸಂಬಂಧಿಸಿದಂತೆ ಕಾಣುತ್ತದೆ ಬಗ್ಗೆ ನಂತರ ಭಾವಿಸುತ್ತೇನೆ ಹಾಗಿದ್ದಲ್ಲಿ

411
00:22:26,000 --> 00:22:29,000
ಮಂಡಳಿಯ ಈ ಎಡಬದಿಯಲ್ಲಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ-ವೇಳೆ

412
00:22:29,000 --> 00:22:33,000
ಮತ್ತು ನಾನು ನೋಡಿ ಎಲ್ಲರೂ ನನ್ನ ಅತ್ಯುತ್ತಮ ಮಾಡುತ್ತೇನೆ ಇದು ವೇಳೆ ಮಂಡಳಿಯ ಈ ಎಡಬದಿಯಲ್ಲಿ

413
00:22:33,000 --> 00:22:37,000
ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ನಿಮ್ಮ RAM ಹೇಳುತ್ತಾರೆ, ಮತ್ತು ಸ್ಟಾಕ್, ಈ ರೀತಿಯಲ್ಲಿ ಅಪ್ ಮೇಲೆ ಬೆಳೆಯಲು ಹೋಗುತ್ತದೆ

414
00:22:37,000 --> 00:22:43,000
ಮತ್ತು ನಾವು ಮುಖ್ಯ ಒಂದು ಕ್ರಿಯೆ ಕರೆ, ಮತ್ತು ಮುಖ್ಯ 2 ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು, X ಮತ್ತು Y ಹೊಂದಿದೆ

415
00:22:43,000 --> 00:22:48,000
ನ ಇಲ್ಲಿ X ಆ ವಿವರಿಸಲು ಅವಕಾಶ, ಮತ್ತು ಈಗ ಇಲ್ಲಿ ವೈ ಈ ವಿವರಿಸಲು,

416
00:22:48,000 --> 00:22:55,000
ಮತ್ತು ಮೌಲ್ಯಗಳನ್ನು 1 ಮತ್ತು 2 ರಲ್ಲಿ ಪುಟ್ ಅವಕಾಶ, ಈ ಇಲ್ಲಿ ಮುಖ್ಯ ಆದ್ದರಿಂದ

417
00:22:55,000 --> 00:22:58,000
ಮತ್ತು ಮುಖ್ಯ ಸ್ವಾಪ್ ಕಾರ್ಯ ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಕರೆ ಮಾಡಿದಾಗ

418
00:22:58,000 --> 00:23:02,000
, ಸ್ಟಾಕ್ ಮೇಲೆ ಸ್ವಾಪ್ ಕಾರ್ಯ ಮೆಮೊರಿ ತನ್ನದೇ ಆದ ಪಟ್ಟೆಗಳು ನೀಡುತ್ತದೆ

419
00:23:02,000 --> 00:23:04,000
ಸ್ಟಾಕ್ ಮೇಲೆ ತನ್ನದೇ ಆದ ಚೌಕಟ್ಟು, ಆದ್ದರಿಂದ ಮಾತನಾಡಲು.

420
00:23:04,000 --> 00:23:08,000
ಇದು ಈ ints 32 ಚೂರುಗಳನ್ನು ಮೀಸಲಿಡುತ್ತದೆ.

421
00:23:08,000 --> 00:23:11,000
ಇದು ಒಂದು ಮತ್ತು ಬಿ ಕರೆ ಸಂಭವಿಸಿದರೆ, ಆದರೆ ಸಂಪೂರ್ಣವಾಗಿ ಕ್ರಮವಿಲ್ಲದ ಇಲ್ಲಿದೆ.

422
00:23:11,000 --> 00:23:13,000
ಅದು ಬಯಸಿದೆ ಯಾವುದೇ ಅವುಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಇರಬಹುದು, ಆದರೆ ಮುಖ್ಯ ಏನಾಗುತ್ತದೆ

423
00:23:13,000 --> 00:23:19,000
ಕರೆಗಳನ್ನು ಸ್ವಾಪ್ ಇದು, ಈ 1 ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಅಲ್ಲಿ ನಕಲನ್ನು ಇರಿಸುತ್ತದೆ, ಅಲ್ಲಿ ಒಂದು ನಕಲನ್ನು ಇರಿಸುತ್ತದೆ ಹೊಂದಿದೆ.

424
00:23:19,000 --> 00:23:23,000
>> ಸ್ವಾಪ್ ರಲ್ಲಿ 1 ಇತರ ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಇಲ್ಲ, ಆದರೂ, ಏನು ಎಂದು? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, ಆದ್ದರಿಂದ, ನನ್ನ ಇಲ್ಲಿ ಇನ್ನೊಂದು 32 ಬಿಟ್ಗಳು ನೀಡಲು ಅವಕಾಶ

426
00:23:27,000 --> 00:23:29,000
ಮತ್ತು ನಾನು ಈ ಕಾರ್ಯದಲ್ಲಿ ಏನು ಮಾಡಿದನು?

427
00:23:29,000 --> 00:23:34,000
ನಾನು ಇಂಟ್ tmp ಒಂದು, ಆದ್ದರಿಂದ ಒಂದು 1 ಗೆಟ್ಸ್ ಹೇಳಿದರು, ಆದ್ದರಿಂದ ನಾವು ಕಳೆದ ಈ ಉದಾಹರಣೆಗೆ ಆಟವಾಡುವ ಮೂಲಕ ನಾನು ಈ ಮಾಡಿದರು.

428
00:23:34,000 --> 00:23:39,000
ನಂತರ ಬೌ ಪಡೆಯುತ್ತದೆ, ಆದ್ದರಿಂದ ಬೌ 2, ಆದ್ದರಿಂದ ಈಗ ಈ 2 ಆಗುತ್ತದೆ,

429
00:23:39,000 --> 00:23:42,000
ಈಗ, ಬೌ ಟೆಂಪ್ ಪಡೆಯುತ್ತದೆ, ಆದ್ದರಿಂದ ಟೆಂಪ್ 1

430
00:23:42,000 --> 00:23:44,000
ಆದ್ದರಿಂದ ಈಗ ಬೌ ಈ ಆಗುತ್ತದೆ.

431
00:23:44,000 --> 00:23:46,000
ಅಭಿನಂದನೆಗಳು. ಇದು ಕೆಲಸ.

432
00:23:46,000 --> 00:23:49,000
ಆದರೆ ನಂತರ ತಕ್ಷಣ ಕಾರ್ಯ ಲಾಭಗಳನ್ನು

433
00:23:49,000 --> 00:23:52,000
ಸ್ವಾಪ್ ನೆನಪಿಗೆ ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮರುಬಳಕೆ ಇದರಿಂದ ಕಣ್ಮರೆಯಾಗುತ್ತದೆ

434
00:23:52,000 --> 00:23:58,000
ಭವಿಷ್ಯದಲ್ಲಿ ಇತರ ಕಾರ್ಯದ ಮೂಲಕ, ಮತ್ತು ಮುಖ್ಯ ನಿಸ್ಸಂಶಯವಾಗಿ ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಾಗಿಲ್ಲ.

435
00:23:58,000 --> 00:24:00,000
ನಾವು, ಮೂಲಭೂತವಾಗಿ ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವ ಒಂದು ದಾರಿ ಬೇಕಿದೆ

436
00:24:00,000 --> 00:24:03,000
ಮತ್ತು ಇಂದು ನಾವು ಅಂತಿಮವಾಗಿ ಆ ಮೂಲಕ ಈ ಮಾಡುವ ರೀತಿಯಲ್ಲಿ ನಿಮಗಿದೆ

437
00:24:03,000 --> 00:24:06,000
ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಕರೆಯುವುದನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.

438
00:24:06,000 --> 00:24:09,000
ನಾವು ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ತಿರುಗುತ್ತದೆ

439
00:24:09,000 --> 00:24:12,000
x ಮತ್ತು y ಪ್ರತಿಗಳನ್ನು ಸಾಗುವ ಮೂಲಕ

440
00:24:12,000 --> 00:24:18,000
ಬದಲಿಗೆ ಏನು ಸಾಗಿಸುವುದರಿಂದ, ನೀವು ಸ್ವಾಪ್ ಕಾರ್ಯನಿರ್ವಹಿಸಲು, ತಿಳಿದಿರುವಿರಿ?

441
00:24:18,000 --> 00:24:20,000
ಹೌದು, ವಿಳಾಸಕ್ಕೆ ಬಗ್ಗೆ ಏನು?

442
00:24:20,000 --> 00:24:22,000
ನಾವು, ಹೆಚ್ಚಿನ ವಿವರ ವಿಳಾಸಗಳನ್ನು ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಮಾಡಿಲ್ಲ

443
00:24:22,000 --> 00:24:25,000
ಆದರೆ ಈ ಕಪ್ಪು ಹಲಗೆಯ ನನ್ನ ಕಂಪ್ಯೂಟರ್ನ ನೆನಪನ್ನು ವೇಳೆ

444
00:24:25,000 --> 00:24:28,000
ನಾವು ಖಂಡಿತವಾಗಿ ನನ್ನ ರಾಮ್ ಬೈಟ್ಗಳು ಸಂಖ್ಯಾ ಆರಂಭಿಸುವುದಕ್ಕಿಂತ

445
00:24:28,000 --> 00:24:31,000
ಮತ್ತು ಈ ಬೈಟ್ # 1 ಎಂದು ಹೇಳುತ್ತಾರೆ, ಈ ಬೈಟ್ # 3, # 2 ಬೈಟ್

446
00:24:31,000 --> 00:24:35,000
ಬೈಟ್ # 4, ಬೈಟ್ # ... 2 ಬಿಲಿಯನ್ ನಾನು RAM ನ 2 ಗಿಗಾಬೈಟ್ ಹೊಂದಿದ್ದರೆ,

447
00:24:35,000 --> 00:24:38,000
ಆದ್ದರಿಂದ ನಾವು ಖಚಿತವಾಗಿ ಕೆಲವು ನಿರಂಕುಶ ಸಂಖ್ಯಾ ಯೋಜನೆಯನ್ನು ಮಂದಿ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

448
00:24:38,000 --> 00:24:41,000
ನನ್ನ ಕಂಪ್ಯೂಟರ್ನ ಎಲ್ಲಾ ಪ್ರತ್ಯೇಕ ಬೈಟ್ಗಳು ಫಾರ್.

449
00:24:41,000 --> 00:24:43,000
>> ನಾನು ಸ್ವಾಪ್ ಹೀಗಾದರೆ ಬದಲಿಗೆ ಕರೆ ಮಾಡಿದಾಗ

450
00:24:43,000 --> 00:24:47,000
x ಮತ್ತು y ಪ್ರತಿಗಳನ್ನು ಬದಲಿಗೆ ಪಾಸ್

451
00:24:47,000 --> 00:24:51,000
ಏಕೆ ಬದಲು, ಇಲ್ಲಿ x ನ ವಿಳಾಸದಲ್ಲಿ ತೇರ್ಗಡೆಹೊಂದಿಲ್ಲ

452
00:24:51,000 --> 00:24:55,000
ಇಲ್ಲಿ ವೈ ವಿಳಾಸವನ್ನು, ಮೂಲಭೂತವಾಗಿ ಅಂಚೆ ವಿಳಾಸಕ್ಕೆ

453
00:24:55,000 --> 00:24:59,000
ಅವರು ಮಾಹಿತಿ ಇದ್ದರೆ x ಮತ್ತು y ಕಾರಣ ನಂತರ, ವಿನಿಮಯ

454
00:24:59,000 --> 00:25:01,000
x ಮತ್ತು y ನೆನಪಿಗಾಗಿ ವಿಳಾಸ,

455
00:25:01,000 --> 00:25:04,000
ನಾವು ಅವರಿಗೆ ಸ್ವಲ್ಪ ತರಬೇತಿ ವೇಳೆ, ನಂತರ, ವಿನಿಮಯ

456
00:25:04,000 --> 00:25:07,000
ಅವರು ಸಂಭಾವ್ಯವಾಗಿ, ಆದ್ದರಿಂದ ಮಾತನಾಡಲು, ಆ ವಿಳಾಸಕ್ಕೆ ಚಾಲನೆ ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

457
00:25:07,000 --> 00:25:11,000
X, ಹಾಗೂ ಬೇಡ, ನಂತರ, Y ವಿಳಾಸವನ್ನು ಗೆ ಚಾಲನೆ

458
00:25:11,000 --> 00:25:16,000
ವಾಸ್ತವವಾಗಿ ಆ ಮೌಲ್ಯಗಳನ್ನು ಸ್ವತಃ ಪ್ರತಿಗಳನ್ನು ಪಡೆಯಲು ಕೂಡ ಅದೇ, ಅಲ್ಲಿ ಬೇಡ,

459
00:25:16,000 --> 00:25:19,000
ನಾವು ಪ್ರಮುಖ ಸ್ಮರಣೆಗೆ ಎಂದು ಈ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಆದ್ದರಿಂದ ಸಹ

460
00:25:19,000 --> 00:25:23,000
ಮತ್ತು ಈ ಕಾಣುತ್ತದೆ ಸ್ವಾಪ್ ನೆನಪಿಗೆ ಪ್ರಬಲ ಮತ್ತು ಸಿ ಅಪಾಯಕಾರಿಯಾಗಿರುತ್ತದೆ

461
00:25:23,000 --> 00:25:28,000
ಯಾವುದೇ ಕ್ರಿಯೆ, ನಗರದಲ್ಲಿ ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿ ಸ್ಪರ್ಶಕ್ಕೆ ಮಾಡುತ್ತದೆ

462
00:25:28,000 --> 00:25:32,000
ಮತ್ತು ಈ ನೀವು ಸಿ ಕಂಪ್ಯೂಟರ್ ಕಾರ್ಯಕ್ರಮಗಳು ಅತ್ಯಂತ ಅಲಂಕಾರಿಕ ಕೆಲಸಗಳನ್ನು ಮಾಡುವ ಶಕ್ತಿಶಾಲಿ ಆಗಿದೆ

463
00:25:32,000 --> 00:25:36,000
ನೀವು ಅತ್ಯಂತ ಸುಲಭವಾಗಿ ಅಪ್ ಸ್ಕ್ರೂ ಏಕೆಂದರೆ ಈ ಅಪಾಯಕಾರಿ.

464
00:25:36,000 --> 00:25:39,000
ವಾಸ್ತವವಾಗಿ, ಕಾರ್ಯಕ್ರಮಗಳು ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ಈ ದಿನಗಳಲ್ಲಿ ಒಂದು ಉಪಯೋಗಿಸಿಕೊಳ್ಳಬೇಕಾಗಿದೆ

465
00:25:39,000 --> 00:25:42,000
ಪ್ರೋಗ್ರಾಮರ್ ಸಾಧಿಸುವುದಕ್ಕಾಗಿ ಬಗ್ಗೆ ಇನ್ನೂ

466
00:25:42,000 --> 00:25:45,000
ಅವನು ಅಥವಾ ಅವಳು ಅಕ್ಷಾಂಶ ಅವಕಾಶ ಇದೆ ಎಂದು

467
00:25:45,000 --> 00:25:49,000
ಉದ್ದೇಶ ಎಂದು ಮೆಮೊರಿ ಒಂದು ಸ್ಥಳ ಬರೆದ ಎಂದು.

468
00:25:49,000 --> 00:25:51,000
>> ಉದಾಹರಣೆಗೆ, ಅವನು ಅಥವಾ ಅವಳು ಗಾತ್ರದ 10 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುತ್ತದೆ

469
00:25:51,000 --> 00:25:56,000
ಆದರೆ ಆಕಸ್ಮಿಕವಾಗಿ, ಮೆಮೊರಿ ಆ ರಚನೆಯ ಒಳಗೆ 11 ಬೈಟ್ಗಳು ಹಾಕಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ

470
00:25:56,000 --> 00:25:59,000
ಮತ್ತು ನೀವು ಅಮಾನ್ಯವಾಗಿದೆ ಎಂದು ಮೆಮೊರಿ ಭಾಗಗಳಲ್ಲಿ ಸ್ಪರ್ಶಿಸುವ ಪ್ರಾರಂಭಿಸಿ.

471
00:25:59,000 --> 00:26:02,000
ಕೇವಲ ಸಂದರ್ಭೋಚಿತ ಈ, ನೀವು ಕೆಲವು ತಿಳಿದಿದೆ ಎಂದು

472
00:26:02,000 --> 00:26:06,000
ಸಾಫ್ಟ್ವೇರ್ ಸಾಮಾನ್ಯವಾಗಿ, ಸರಣಿ ಸಂಖ್ಯೆಗಳನ್ನು ಅಥವಾ ನೋಂದಣಿ ಕೀಲಿಗಳನ್ನು ಅಪೇಕ್ಷಿಸುತ್ತದೆ

473
00:26:06,000 --> 00:26:08,000
ಫೋಟೋಶಾಪ್ ಮತ್ತು ಪದಗಳ ಮತ್ತು ಈ ರೀತಿಯ ಕಾರ್ಯಕ್ರಮಗಳು.

474
00:26:08,000 --> 00:26:12,000
, ನೀವು ಸ್ವಲ್ಪ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು ಆನ್ಲೈನ್ ಅಲ್ಲಿ, ನೀವು ಕೆಲವು ತಿಳಿದಿರುವಂತೆ, ಬಿರುಕುಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ

475
00:26:12,000 --> 00:26:14,000
ಮತ್ತು voila, ಸರಣಿ ಸಂಖ್ಯೆಯ ಯಾವುದೇ ವಿನಂತಿಯನ್ನು.

476
00:26:14,000 --> 00:26:16,000
ಅದು ಹೇಗೆ ಕೆಲಸ?

477
00:26:16,000 --> 00:26:21,000
ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಈ ವಿಷಯಗಳನ್ನು ಸರಳವಾಗಿ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ಹುಡುಕುತ್ತಾರೆ

478
00:26:21,000 --> 00:26:24,000
ಕಂಪ್ಯೂಟರ್ ನೈಜ ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಪಠ್ಯ ಭಾಗಗಳು

479
00:26:24,000 --> 00:26:28,000
ಕ್ರಮಸಂಖ್ಯೆ ವಿನಂತಿಸಿದ ಇದೆ ಅಲ್ಲಿ ಆ ಕ್ರಿಯೆ, ಎಲ್ಲಿ

480
00:26:28,000 --> 00:26:31,000
ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿದ್ದಾಗ, ಮತ್ತು ಆ ಜಾಗವನ್ನು ಬದಲಿಸಿ, ಅಥವಾ

481
00:26:31,000 --> 00:26:33,000
ಕೀಲಿ ವಾಸ್ತವವಾಗಿ ಸಂಗ್ರಹವಾಗಿರುವ ಅಲ್ಲಿ ನೀವು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು

482
00:26:33,000 --> 00:26:37,000
ಏನೋ ಬಳಸಿಕೊಂಡು ದೋಷಸೂಚಕವು ಎಂದು, ಮತ್ತು ನೀವು ಸಾಫ್ಟ್ವೇರ್ ರೀತಿಯಲ್ಲಿ ಬಿರುಕು ಮಾಡಬಹುದು.

483
00:26:37,000 --> 00:26:40,000
ಈ, ಮುಂದಿನ ಕೆಲವು ದಿನಗಳಲ್ಲಿ ಈ ನಮ್ಮ ಉದ್ದೇಶ ಎಂದು ಹೇಳಲು ಇಲ್ಲ

484
00:26:40,000 --> 00:26:42,000
ಆದರೆ ಇದು ನೈಜ ಜಗತ್ತಿನ ಶಾಖೋಪಶಾಖೆಗಳನ್ನು ಹೊಂದಿದೆ.

485
00:26:42,000 --> 00:26:45,000
ಒಂದು, ಸಾಫ್ಟ್ವೇರ್ ಕಳವು ಒಳಗೊಂಡಿದೆ ನಡೆಯುವ

486
00:26:45,000 --> 00:26:47,000
ಆದರೆ ಇಡೀ ಯಂತ್ರಗಳು ಹೊಂದಾಣಿಕೆಯನ್ನು ಕೂಡ ಇಲ್ಲ.

487
00:26:47,000 --> 00:26:50,000
>> ವಾಸ್ತವವಾಗಿ, ಯಾವಾಗ ವೆಬ್ಸೈಟ್ಗಳು ಈ ದಿನಗಳ ಬಳಸಿಕೊಳ್ಳುತ್ತಾರೆ

488
00:26:50,000 --> 00:26:53,000
ಮತ್ತು ರಾಜಿ ಮತ್ತು ಡೇಟಾವನ್ನು ಸೋರಿಕೆಯಾಗಿದೆ ಮತ್ತು ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಅಪಹರಣಕ್ಕೊಳಗಾಗುತ್ತವೆ

489
00:26:53,000 --> 00:26:58,000
ಈ ಆಗಾಗ್ಗೆ ಒಬ್ಬರ ಮೆಮೊರಿ ಕಳಪೆ ನಿರ್ವಹಣೆಗೆ ಸಂಬಂಧಿಸಿದೆ,

490
00:26:58,000 --> 00:27:01,000
ಅಥವಾ, ಡೇಟಾಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ, ವೈಫಲ್ಯ ನಿರೀಕ್ಷಿಸುವ

491
00:27:01,000 --> 00:27:03,000
ಮುಂಬರುವ ವಾರಗಳಲ್ಲಿ ಮೇಲೆ ಆದ್ದರಿಂದ ಹೆಚ್ಚು ವ್ಯತಿರಿಕ್ತ ಇನ್ಪುಟ್,

492
00:27:03,000 --> 00:27:07,000
ಆದರೆ ಈಗ ನೀವು ಮಾಡಬಹುದು ಹಾನಿಯನ್ನು ರೀತಿಯ ಕೇವಲ ಒಂದು ರಹಸ್ಯ ಮುನ್ನೋಟವನ್ನು

493
00:27:07,000 --> 00:27:11,000
ಸಾಕಷ್ಟು ವಿಷಯಗಳನ್ನು HOOD ಕೆಳಗೆ ಹೇಗೆ ಕೆಲಸ ಅರ್ಥವಾಗದೆ ಅದಕ್ಕೆ.

494
00:27:11,000 --> 00:27:14,000
ನ ಈ ಮುರಿದಿದೆ ಏಕೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಬಗ್ಗೆ ತಿಳಿಯಲು ಅವಕಾಶ

495
00:27:14,000 --> 00:27:17,000
ಉಪಕರಣವನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚು ಮತ್ತು ಹೆಚ್ಚು ಉಪಯುಕ್ತ ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ

496
00:27:17,000 --> 00:27:19,000
ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳು ಸಂಕೀರ್ಣ ಸ್ವೀಕರಿಸುತ್ತೇವೆ.

497
00:27:19,000 --> 00:27:21,000
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಒಂದು ದೋಷವನ್ನು ಹೊಂದಿತ್ತು ಮಾಡಿದ ಇದುವರೆಗಿನ ಮಾಡಿದಾಗ

498
00:27:21,000 --> 00:27:23,000
ನೀವು ಅದನ್ನು ಡೀಬಗ್ ಬಗ್ಗೆ ಹೋದವು?

499
00:27:23,000 --> 00:27:25,000
ನಿಮ್ಮ ತಂತ್ರಗಳನ್ನು ನಿಮ್ಮ TF ಬೋಧಿಸಿದ ಎಂಬುದನ್ನು, ಇದುವರೆಗಿನ ಎಂದು

500
00:27:25,000 --> 00:27:27,000
ಅಥವಾ ಕೇವಲ ಸ್ವಶಿಕ್ಷಿತ?

501
00:27:27,000 --> 00:27:29,000
[ವಿದ್ಯಾರ್ಥಿ] printf.

502
00:27:29,000 --> 00:27:31,000
ನೀವು ನೋಡಲು ಬಯಸಿದರೆ printf, ಆದ್ದರಿಂದ printf ಬಹುಶಃ ಆ ನಿಮ್ಮ ಸ್ನೇಹಿತ ಮಾಡಲಾಗಿದೆ

503
00:27:31,000 --> 00:27:33,000
ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಒಳಗೆ ಇಂದಿನ

504
00:27:33,000 --> 00:27:36,000
ನೀವು printf ಇಲ್ಲಿ printf ಇಲ್ಲಿ printf ಇಲ್ಲಿ ಇರಿಸಿ.

505
00:27:36,000 --> 00:27:38,000
ನಂತರ ಅದನ್ನು ಚಾಲನೆ, ಮತ್ತು ಪರದೆಯ ಮೇಲೆ ವಿಷಯದ ಸಂಪೂರ್ಣ ಗುಂಪೇ ಪಡೆಯಿರಿ

506
00:27:38,000 --> 00:27:43,000
ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ತಪ್ಪು ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ತಿಳಿಯಲು ಬಳಸಬಹುದಾದ.

507
00:27:43,000 --> 00:27:45,000
>> Printf, ಒಂದು ಶಕ್ತಿಶಾಲಿ ವಿಷಯ ತಳಿಗಿಂತ

508
00:27:45,000 --> 00:27:47,000
ಆದರೆ ಒಂದು ಕೈಯಿಂದ ಪ್ರಕ್ರಿಯೆಯಾಗಿದೆ.

509
00:27:47,000 --> 00:27:49,000
ನೀವು ಒಂದು printf ಇಲ್ಲಿ, ಇಲ್ಲಿ printf ಹಾಕಬೇಕು

510
00:27:49,000 --> 00:27:51,000
ಮತ್ತು ನೀವು ಲೂಪ್ ಒಳಗೆ ಅದನ್ನು ಮಾಡಿದರೆ ನೀವು 100 ಸಾಲುಗಳನ್ನು ಸಿಗುತ್ತವೆ

511
00:27:51,000 --> 00:27:53,000
ನೀವು ಮೂಲಕ ಶೋಧನಾ ಕಾರ್ಯಕ್ಕಾಗಿ ಹೊಂದಿರುವ ಉತ್ಪಾದನೆಯ.

512
00:27:53,000 --> 00:27:58,000
ಇದು, ಡೀಬಗ್ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಒಂದು ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಅಥವಾ ಪರಸ್ಪರ ಯಾಂತ್ರಿಕ ಅಲ್ಲ

513
00:27:58,000 --> 00:28:00,000
ಆದರೆ thankfully ಪರ್ಯಾಯಗಳಿರುತ್ತವೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

514
00:28:00,000 --> 00:28:03,000
GDB ಎಂದು ಉದಾಹರಣೆಗೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ, ಗ್ನೂ ಡೀಬಗರ್, ಇಲ್ಲ

515
00:28:03,000 --> 00:28:06,000
ಇದು ನೀವು ಬಳಸಲು ಹೇಗೆ ಸ್ವಲ್ಪ ರಹಸ್ಯ ಹೊಂದಿದೆ.

516
00:28:06,000 --> 00:28:08,000
ಇದು, ನಾನೂ ಸ್ವಲ್ಪ ಸಂಕೀರ್ಣ, ಆದರೆ

517
00:28:08,000 --> 00:28:11,000
ಈ ಈ ವಾರದಲ್ಲಿ ಮಾಡಿದರೆ ಅಲ್ಲಿ ಆ ವಸ್ತುಗಳ ಒಂದು ಮತ್ತು ಮುಂದಿನ

518
00:28:11,000 --> 00:28:14,000
GDB ಸ್ವಲ್ಪ ತಿಳಿಯಲು ಹೆಚ್ಚುವರಿ ಗಂಟೆ

519
00:28:14,000 --> 00:28:18,000
ಇದು, ದೀರ್ಘಾವಧಿಯಲ್ಲಿ ನೀವು ಗಂಟೆಗಳ ಪ್ರಾಯಶಃ ಹತ್ತಾರು ಉಳಿಸುತ್ತದೆ

520
00:28:18,000 --> 00:28:21,000
ಆ ಮೂಲಕ, ನೀವು ಈ ಕೆಲಸವನ್ನು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಒಂದು ಟೀಸರ್ ನೀಡಲು ಅವಕಾಶ.

521
00:28:21,000 --> 00:28:23,000
>> ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಆಗಿದ್ದೇನೆ.

522
00:28:23,000 --> 00:28:26,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಪ್ರೋಗ್ರಾಂ, buggy3 ಕಂಪೈಲ್ ಲೆಟ್.

523
00:28:26,000 --> 00:28:28,000
ಇದು ಸದ್ಯೋಚಿತವಾಗಿಲ್ಲ ಈಗಾಗಲೇ.

524
00:28:28,000 --> 00:28:31,000
ನಾವು ಸ್ವಲ್ಪ ಹಿಂದಕ್ಕೆ ಮಾಡಿದರು, ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಅದು ಮುರಿದು ಸುಮ್ಮನೆ ಹಾಗೆ ನನ್ನನ್ನು ಚಲಾಯಿಸಲು ಅವಕಾಶ.

525
00:28:31,000 --> 00:28:34,000
ಆದರೆ ಏಕೆ ಇದು? ಬಹುಶಃ ನಾನು ಸ್ವಾಪ್ ಕಾರ್ಯ ಸಂಕುಚಿತಗೊಳಿಸಲ್ಪಟ್ಟಿರುವ.

526
00:28:34,000 --> 00:28:37,000
ಬಹುಶಃ ಇದು ಒಂದು ಮತ್ತು ಬಿ ಇಲ್ಲಿದೆ. ನಾನು ಸ್ವಲ್ಪ ಸರಿಯಾಗಿ ಅವುಗಳನ್ನು ಸಂಚರಿಸುವ ಇಲ್ಲ.

527
00:28:37,000 --> 00:28:39,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಮಾಡೋಣ.

528
00:28:39,000 --> 00:28:43,000
ಬದಲಿಗೆ ಕೇವಲ, ನನ್ನ ಬದಲಿಗೆ ಈ ಪ್ರೋಗ್ರಾಂ GDB ರನ್ ಅವಕಾಶ buggy3 ರನ್

529
00:28:43,000 --> 00:28:48,000
ಮತ್ತು ನಾನು, buggy3 ರನ್ ಅದನ್ನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

530
00:28:48,000 --> 00:28:52,000
ಮತ್ತು ನಾನು ಆಜ್ಞೆ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟನ್ನು, ತುಐ ಒಳಗೊಂಡ ಪಡೆಯಲಿದ್ದೇನೆ

531
00:28:52,000 --> 00:28:55,000
ಮತ್ತು ನಾವು ನೆನಪಿನಲ್ಲಿ ವಿಶೇಷ ಮುಂದಿನ ಸಮಸ್ಯೆಗಳು ಈ ಹಾಕುತ್ತೇವೆ.

532
00:28:55,000 --> 00:28:57,000
ಈಗ ಈ ಕಪ್ಪು ಮತ್ತು ಬಿಳಿ ಇಂಟರ್ಫೇಸ್, ಮತ್ತೆ, ಸುಮಾರು ಬೇರ್ಪಡಿಸಿದ

533
00:28:57,000 --> 00:28:59,000
ಈ ಇರುವುದರಿಂದ ಮೊದಲು ಸ್ವಲ್ಪ ಅಗಾಧ ಹೊಂದಿದೆ

534
00:28:59,000 --> 00:29:02,000
ಇಲ್ಲಿ ಕೆಳಗೆ ಖಾತರಿ ಮಾಹಿತಿ, ಆದರೆ ಕನಿಷ್ಠ ಪರಿಚಿತ ವಿಷಯವೆಂದರೆ.

535
00:29:02,000 --> 00:29:04,000
ವಿಂಡೋ ಮೇಲಿನ ನನ್ನ ನಿಜವಾದ ಕೋಡ್, ಆಗಿದೆ

536
00:29:04,000 --> 00:29:08,000
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಸ್ಕ್ರಾಲ್ ವೇಳೆ, ನನ್ನ ಫೈಲ್ ತುಂಬಾ ಮೇಲಕ್ಕೆ ಸ್ಕ್ರಾಲ್ ಅವಕಾಶ

537
00:29:08,000 --> 00:29:11,000
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಈ ವಿಂಡೋದ ಕೆಳಭಾಗದಲ್ಲಿ buggy3.c, ಮತ್ತು ಸೂಚನೆ ಇಲ್ಲ

538
00:29:11,000 --> 00:29:13,000
ನಾನು ಈ GDB ಪ್ರಾಂಪ್ಟ್ ಹೊಂದಿರುತ್ತವೆ.

539
00:29:13,000 --> 00:29:16,000
>> ಈ ನನ್ನ ಸಾಮಾನ್ಯ ಜಾನ್ ಹಾರ್ವರ್ಡ್ ಪ್ರಾಂಪ್ಟ್ ಅದೇ ಅಲ್ಲ.

540
00:29:16,000 --> 00:29:19,000
ಈ ನನ್ನ GDB ನಿಯಂತ್ರಿಸಲು ಅವಕಾಶ ವಿಶೇಷವೇನು ಎಂದು ತಿಳಿಸುವ ಹೊಂದಿದೆ.

541
00:29:19,000 --> 00:29:21,000
GDB ಒಂದು ದೋಷಸೂಚಕವು ಹೊಂದಿದೆ.

542
00:29:21,000 --> 00:29:24,000
ಎ ದೋಷಸೂಚಕವು ನೀವು ಸಂಚರಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುವ ಒಂದು ಕಾರ್ಯಕ್ರಮ

543
00:29:24,000 --> 00:29:27,000
ಲೈನ್ ಲೈನ್ ಮೂಲಕ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸಾಲಿನ ನಿರ್ವಹಣೆ,

544
00:29:27,000 --> 00:29:30,000
ರೀತಿಯಲ್ಲಿ ನೀವು ಪ್ರೋಗ್ರಾಂ ಬಯಸುವ ಏನು ಮಾಡುವ ಜೊತೆಗೆ,

545
00:29:30,000 --> 00:29:33,000
ಸಹ, ಹೆಚ್ಚು ಮುಖ್ಯವಾಗಿ, ಕಾರ್ಯಗಳನ್ನು ಕರೆ, ಅಥವಾ ನೋಡುತ್ತಿರುವ

546
00:29:33,000 --> 00:29:35,000
ವಿವಿಧ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ನ ಮೌಲ್ಯಗಳಲ್ಲಿ.

547
00:29:35,000 --> 00:29:37,000
ನ ಮುಂದೆ ಹೋಗಿ ಈ ಮಾಡೋಣ.

548
00:29:37,000 --> 00:29:40,000
ನಾನು, ಮುಂದೆ ಹೋಗಿ GDB ಯ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ರನ್ ಟೈಪ್ ಪಡೆಯಲಿದ್ದೇನೆ

549
00:29:40,000 --> 00:29:43,000
ಆದ್ದರಿಂದ ನಾನು ಟೈಪಿಸಿದ ಹೊಸದೊಂದು ಪರದೆಯ ಕೆಳಗಿನ ಎಡಭಾಗದಲ್ಲಿ ಗಮನಕ್ಕೆ,

550
00:29:43,000 --> 00:29:45,000
ಮತ್ತು ನಾನು ನಮೂದಿಸಿ ಹಿಟ್ ಮಾಡಿದ, ಮತ್ತು ಏನು ಮಾಡಿದನು?

551
00:29:45,000 --> 00:29:50,000
ಇದು ಅಕ್ಷರಶಃ ನನ್ನ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಿರ್ವಹಿಸಿದ, ಆದರೆ ನಾನು ನಿಜವಾಗಿ ಹೆಚ್ಚು ಇಲ್ಲಿ ಮೇಲೆ ಹೋಗಿ ಗಮನಿಸಲಾಗಲಿಲ್ಲ

552
00:29:50,000 --> 00:29:55,000
ನಾನು ವಾಸ್ತವವಾಗಿ ದೋಷಸೂಚಕವು ಹೇಳಿದರು ಏಕೆಂದರೆ

553
00:29:55,000 --> 00:29:57,000
ಸಮಯದಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಕ್ಷಣದಲ್ಲಿ ತಾತ್ಕಾಲಿಕ.

554
00:29:57,000 --> 00:29:59,000
ಕೇವಲ ರನ್ ಟೈಪ್ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುತ್ತದೆ.

555
00:29:59,000 --> 00:30:01,000
ನಾನು ನಿಜವಾಗಿ ಏನು ಕಾಣುವುದಿಲ್ಲ. ನಾನು ಕುಶಲತೆಯಿಂದ ಸಾಧ್ಯವಿಲ್ಲ.

556
00:30:01,000 --> 00:30:03,000
>> ಬದಲಿಗೆ ಈ ಮಾಡಿ.

557
00:30:03,000 --> 00:30:08,000
ಈ GDB ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ನನ್ನ ಬದಲಿಗೆ ನಮೂದಿಸಿ, ಬ್ರೇಕ್ ಟೈಪ್ ಅವಕಾಶ.

558
00:30:08,000 --> 00:30:10,000
ನಾನು ಟೈಪಿಸಲು ಅರ್ಥ ಅಲ್ಲ.

559
00:30:10,000 --> 00:30:13,000
ಬ್ರೇಕ್ ಮುಖ್ಯ ಟೈಪ್ ಬದಲಿಗೆ ನಾವು.

560
00:30:13,000 --> 00:30:15,000
ಅಂದರೆ, ನಾನು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಕರೆಯುವುದನ್ನು, ಸೆಟ್ ಬಯಸುವ

561
00:30:15,000 --> 00:30:18,000
ಇದನ್ನು ಮುರಿಯಲು ಅಥವಾ ವಿರಾಮ ಏಕೆಂದರೆ ಯೋಗ್ಯವಾಗಿ ಹೆಸರಿಸಲಾಗಿದೆ

562
00:30:18,000 --> 00:30:21,000
ನಿರ್ದಿಷ್ಟ ಸ್ಥಳದಲ್ಲಿ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ನಿರ್ವಹಣೆ.

563
00:30:21,000 --> 00:30:23,000
ಮುಖ್ಯ ನನ್ನ ಕಾರ್ಯದ ಹೆಸರು.

564
00:30:23,000 --> 00:30:25,000
GDB ಸಾಕಷ್ಟು ಸ್ಮಾರ್ಟ್ ಗಮನಿಸಿ.

565
00:30:25,000 --> 00:30:28,000
ಇದು ಮುಖ್ಯ ಸಾಲಿನ 18 ಸುಮಾರು ಆರಂಭಿಸಲು ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ಕಾಣಿಸಿಕೊಂಡಿತ್ತು

566
00:30:28,000 --> 00:30:32,000
buggy3.c ಆಫ್, ಮತ್ತು ನಂತರ ಮೇಲಿನ ಎಡಭಾಗದಲ್ಲಿ ಇಲ್ಲಿ ಗಮನಿಸಿ

567
00:30:32,000 --> 00:30:34,000
B + ಲೈನ್ 18 ಹಕ್ಕನ್ನು ಮುಂದಿನ ಹೊಂದಿದೆ.

568
00:30:34,000 --> 00:30:38,000
ನಾನು ಲೈನ್ 18 ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಸೆಟ್ ಎಂದು ನನಗೆ ನೆನಪಿಸುವ ನ.

569
00:30:38,000 --> 00:30:42,000
ಈ ಬಾರಿ ನಾನು ರನ್ ಟೈಪ್ ಮಾಡಿದಾಗ, ನನ್ನ ಪ್ರೊಗ್ರಾಮನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ

570
00:30:42,000 --> 00:30:45,000
ಅಪ್ ರವರೆಗೆ ಇದು, ಆ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್ಸ್

571
00:30:45,000 --> 00:30:48,000
ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಮ್ ಸಾಲು 18 ನಲ್ಲಿ ನನಗೆ ವಿರಾಮ ತಿನ್ನುವೆ.

572
00:30:48,000 --> 00:30:50,000
ಇಲ್ಲಿ ನಾವು ಹೋಗಿ ರನ್.

573
00:30:50,000 --> 00:30:53,000
ಏನು ಸಂಭವಿಸಿಲ್ಲ ಕಂಡುಬರುತ್ತದೆ, ಆದರೆ ಕೆಳಭಾಗದಲ್ಲಿ ಸೂಚನೆ ಬಿಟ್ಟು

574
00:30:53,000 --> 00:30:58,000
ಆರಂಭಿಕ ಪ್ರೋಗ್ರಾಮ್, buggy3, buggy3.c ಸಾಲಿನ 18 ಮುಖ್ಯ ರಲ್ಲಿ ಬ್ರೇಕ್ಪಾಯಿಂಟ್ 1.

575
00:30:58,000 --> 00:31:00,000
ನಾನು ಈಗ ಏನು ಮಾಡಬೇಕು?

576
00:31:00,000 --> 00:31:03,000
>> ಗಮನಿಸಿ ನಾನು, ಮುದ್ರಣ ವಿಷಯಗಳನ್ನು ಟೈಪ್ ಆರಂಭಿಸಬಹುದು

577
00:31:03,000 --> 00:31:08,000
ಅಲ್ಲ printf, ಮುದ್ರಣ X, ಮತ್ತು ಈಗ ಆ ಆಶ್ಚರ್ಯವಾಗಿದೆ.

578
00:31:08,000 --> 00:31:11,000
ನಾವು ನೋಡುತ್ತಾರೆ ಎಂದು $ 1, ಕೇವಲ ಕುತೂಹಲ ಹೊಂದಿದೆ

579
00:31:11,000 --> 00:31:14,000
ನೀವು ಏನಾದರೂ ಮುದ್ರಿಸಲು ಪ್ರತಿ ಬಾರಿ ನೀವು ಹೊಸ $ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು.

580
00:31:14,000 --> 00:31:18,000
ಎಂದು, ನೀವು ಸಂದರ್ಭದಲ್ಲಿ ಹಿಂದಿನ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂದಕ್ಕೆ ನೋಡಿ ಎಂದು ಇದರಿಂದ

581
00:31:18,000 --> 00:31:21,000
ಆದರೆ ಈಗ ಯಾವ ಮುದ್ರಣ ನನಗೆ ಹೇಳುವ ಇದೆ ಎಂದು ಕಥೆ ಈ ಹಂತದಲ್ಲಿ X ನ ಮೌಲ್ಯ

582
00:31:21,000 --> 00:31:26,000
ಸ್ಪಷ್ಟವಾಗಿ 134514032 ಹೊಂದಿದೆ.

583
00:31:26,000 --> 00:31:29,000
ಏನು? ಸಹ ಅಲ್ಲಿ ಬರುತ್ತದೆಯೇ?

584
00:31:29,000 --> 00:31:31,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

585
00:31:31,000 --> 00:31:34,000
ವಾಸ್ತವವಾಗಿ, ಈ ನಾವು ಕಸ ಮೌಲ್ಯವನ್ನು ಕರೆ ನಾವು ಏನು, ಮತ್ತು ನಾವು, ಇನ್ನೂ ಈ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಮಾಡಿಲ್ಲ

586
00:31:34,000 --> 00:31:37,000
ಆದರೆ ನೀವು ಅಸ್ಥಿರ ಆರಂಭಿಸಲು ಕಾರಣವನ್ನು

587
00:31:37,000 --> 00:31:40,000
ಸ್ಪಷ್ಟವಾಗಿ ಆದ್ದರಿಂದ ಅವರು ನೀವು ಅವುಗಳನ್ನು ಹೊಂದಲು ಬಯಸುವ ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿವೆ.

588
00:31:40,000 --> 00:31:44,000
ಆದರೆ ಕ್ಯಾಚ್ ನೀವು ಅಸ್ಥಿರ ಘೋಷಿಸಬಹುದು ಸ್ಮರಿಸುತ್ತಾರೆ ಇದೆ

589
00:31:44,000 --> 00:31:46,000
ನನ್ನ ಸಿಗ್ಮಾ ಉದಾಹರಣೆಯಲ್ಲಿ ಕೊಂಚ ಹಿಂದೆ ಮಾಡಿದ ಹಾಗೆ

590
00:31:46,000 --> 00:31:48,000
ನಿಜವಾಗಿಯೂ ಒಂದು ಮೌಲ್ಯವನ್ನು ನೀಡದೆ.

591
00:31:48,000 --> 00:31:50,000
ನಾನು ಸಿಗ್ಮಾ ಇಲ್ಲಿ ಮೇಲೆ ಏನು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

592
00:31:50,000 --> 00:31:52,000
ನಾನು N ಡಿಕ್ಲೇರ್ಡ್, ಆದರೆ ನಾನು ಯಾವ ಮೌಲ್ಯವನ್ನು ನೀಡಿಲ್ಲ?

593
00:31:52,000 --> 00:31:56,000
ಇಲ್ಲ, ನಾನು ತಿಳಿದಿತ್ತು ಏಕೆಂದರೆ ಮುಂದಿನ ಕೆಲವು ಸಾಲುಗಳು

594
00:31:56,000 --> 00:31:59,000
GetInt N ಒಳಗಿನ ಮೌಲ್ಯದ ಹೊರೆಯನ್ನು ಸಮಸ್ಯೆಯ ಕಾಳಜಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

595
00:31:59,000 --> 00:32:02,000
>> ಆದರೆ ಲೈನ್ 11 ಕಥೆಯನ್ನು ಈ ಹಂತದಲ್ಲಿ

596
00:32:02,000 --> 00:32:05,000
ಮತ್ತು ಸಾಲಿನ 12 ಮತ್ತು ಸಾಲು 13 ಮತ್ತು ಸಾಲು 14

597
00:32:05,000 --> 00:32:08,000
ಆ ಅನೇಕ ಸಾಲುಗಳ ಉದ್ದಕ್ಕೂ N ಮೌಲ್ಯವನ್ನು ಏನು?

598
00:32:08,000 --> 00:32:10,000
ಸಿ ನೀವು ಗೊತ್ತಿಲ್ಲ.

599
00:32:10,000 --> 00:32:14,000
ಸಾಮಾನ್ಯವಾಗಿ ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯ, ಕೆಲವು ಸಂಪೂರ್ಣವಾಗಿ ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯ

600
00:32:14,000 --> 00:32:17,000
ಹಿಂದಿನ ಕೆಲವು ಫಂಕ್ಷನ್ ನಿಂದ ಅವಶ್ಯಕವಾಗಿ ಉಳಿದ ಎಂದು

601
00:32:17,000 --> 00:32:21,000
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ರನ್ ಆದ್ದರಿಂದ, ರನ್ ಮಾಡಲ್ಪಟ್ಟಿತು

602
00:32:21,000 --> 00:32:24,000
ಕ್ರಿಯೆ ಕ್ರಿಯೆ, ಕೆಲಸ, ಕಾರ್ಯ ಗೆಟ್ಸ್ ಸ್ಮರಿಸುತ್ತಾರೆ.

603
00:32:24,000 --> 00:32:27,000
ಎಲ್ಲಾ ಚೌಕಟ್ಟುಗಳು, ಆ ಕಾರ್ಯಗಳನ್ನು ಮರಳಿ ಮೆಮೊರಿ ಮೇಲೆ, ಮತ್ತು ಪಡೆಯುತ್ತೀರಿ

604
00:32:27,000 --> 00:32:31,000
ಮತ್ತು ಕೇವಲ ಹಾಗೆ ನಾನು ಅವರ ಸ್ಮರಣೆ ಅಂತಿಮವಾಗಿ ಮರುಬಳಕೆ ಇದೆ ಎರೇಸರ್ ಸೂಚಿಸಿದ.

605
00:32:31,000 --> 00:32:37,000
ಅಲ್ಲದೆ, ಇದು ಕೇವಲ ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಈ ವ್ಯತ್ಯಯ X ಸಂಭವಿಸುತ್ತದೆ

606
00:32:37,000 --> 00:32:41,000
134514032 ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿತ್ತು ತೋರುತ್ತದೆ

607
00:32:41,000 --> 00:32:44,000
ಹಿಂದಿನ ಕೆಲವು ಫಂಕ್ಷನ್ ನಿಂದ, ಯಾವುದೇ ನಾನು ಬರೆದ.

608
00:32:44,000 --> 00:32:47,000
ಅದು, ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಬಂದಿದೆ ಏನೋ ಆಗಿರಬಹುದು

609
00:32:47,000 --> 00:32:49,000
HOOD ಕೆಳಗೆ ಕೆಲವು ಕಾರ್ಯ.

610
00:32:49,000 --> 00:32:52,000
>> ಸರಿ, ಆ ಉತ್ತಮ, ಆದರೆ ಮುಂದಿನ ಲೈನ್ ನತ್ತ ಈಗ ನೋಡೋಣ.

611
00:32:52,000 --> 00:32:55,000
ನನ್ನ GDB ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ "ಮುಂದಿನ" ನಮೂದಿಸಿ ಮತ್ತು ನಾನು, enter ಅನ್ನು ಒತ್ತಿ

612
00:32:55,000 --> 00:32:58,000
ಗಮನಿಸಿ ಆ, ಸಾಲು 19 ಚಲನೆಗಳು ಕೆಳಗೆ ಹೈಲೈಟ್

613
00:32:58,000 --> 00:33:01,000
ಆದರೆ ತಾರ್ಕಿಕ ಅಂತರಾರ್ಥವೇನೆಂದರೆ ಸಾಲಿನ 18

614
00:33:01,000 --> 00:33:06,000
ಈಗ ಮುಗಿದಿದೆ ನಾನು ಮತ್ತೆ ಟೈಪ್ ಹಾಗಿದ್ದಲ್ಲಿ, ಪಾಲಿಸಲು "ಮುದ್ರಣ X"

615
00:33:06,000 --> 00:33:10,000
ನಾನು ಈಗ 1 ನೋಡಿ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಾನು.

616
00:33:10,000 --> 00:33:14,000
ಮತ್ತೆ, $ ಸ್ಟಫ್ GDB ನೀವು ನೆನಪಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ

617
00:33:14,000 --> 00:33:17,000
ಅಚ್ಚುಗಳ ಇತಿಹಾಸವನ್ನು ನೀವು ಮಾಡಿದ ಎಂದು ಕೇಳಿ.

618
00:33:17,000 --> 00:33:21,000
ಈಗ ನನ್ನ ಮುಂದೆ ಹೋಗಿ ವೈ ಮುದ್ರಿಸುತ್ತದೆ ಅವಕಾಶ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ವೈ ಮತ್ತು ಕೆಲವು ಅಸಾಮಾನ್ಯ ಮೌಲ್ಯವಾಗಿರುತ್ತದೆ

619
00:33:21,000 --> 00:33:24,000
ಆದರೆ ಯಾವುದೇ ದೊಡ್ಡ ಒಪ್ಪಂದ ಸಾಲು 19 ರಲ್ಲಿ ನಾವು ಬಗ್ಗೆ ಇದು ನಿಯೋಜಿಸಲು ಆಗಿರುವ ಕಾರಣ

620
00:33:24,000 --> 00:33:27,000
ಮೌಲ್ಯ 2, ಆದ್ದರಿಂದ ನನಗೆ ಮತ್ತೆ "ಮುಂದಿನ" ಟೈಪ್ ಅವಕಾಶ.

621
00:33:27,000 --> 00:33:29,000
ಮತ್ತು ಈಗ ನಾವು printf ಸಾಲಿನಲ್ಲಿ ಆರ್.

622
00:33:29,000 --> 00:33:31,000
ನನಗೆ ಮುದ್ರಣ X ಮಾಡೋಣ.

623
00:33:31,000 --> 00:33:34,000
ನನಗೆ ಮುದ್ರಣ ವೈ ಮಾಡೋಣ. ನಾನೂ, ನಾನು ಈ ಮುದ್ರಿಸುವ ಸ್ವಲ್ಪ ದಣಿದ ಪಡೆಯುವುದರ ನುಡಿದರು.

624
00:33:34,000 --> 00:33:38,000
ನನ್ನ ಬದಲಿಗೆ "ಪ್ರದರ್ಶನ X" ಮತ್ತು "ಪ್ರದರ್ಶನ ವೈ," ಟೈಪ್ ಲೆಟ್

625
00:33:38,000 --> 00:33:41,000
ಈಗ ಪ್ರತಿ ಬಾರಿ ನಾನು ಭವಿಷ್ಯದಲ್ಲಿ ಒಂದು ಆಜ್ಞೆಯನ್ನು ಟೈಪಿಸಿ

626
00:33:41,000 --> 00:33:45,000
ನಾನು ಎಂಬುದನ್ನು ನೆನಪಿಸಲಾಗುತ್ತದೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು x ಮತ್ತು y, X ಮತ್ತು Y, X ಮತ್ತು Y ಇಲ್ಲಿದೆ.

627
00:33:45,000 --> 00:33:48,000
>> ನಾನು ಸಹ, ಒಂದು ಬದಿಗೆ, ಟೈಪ್ "ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರು."

628
00:33:48,000 --> 00:33:50,000
ಮಾಹಿತಿಯನ್ನು ಒಂದು ವಿಶೇಷ ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿದೆ.

629
00:33:50,000 --> 00:33:52,000
ಸ್ಥಳೀಯರು ನನಗೆ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ತೋರಿಸುತ್ತದೆ ಅರ್ಥ.

630
00:33:52,000 --> 00:33:55,000
ನಾನು ಮರೆತರೆ ಅಥವಾ ಈ ಒಂದು ಅಸಾಮಾನ್ಯ, ಸಂಕೀರ್ಣ ಕಾರ್ಯ ಕೇವಲ ಸಂದರ್ಭದಲ್ಲಿ

631
00:33:55,000 --> 00:33:57,000
ನಾನು ಅಥವಾ ಬೇರೊಬ್ಬರ ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರು ನಿಮಗೆ ತಿಳಿಸುವರು ಬರೆದಿದ್ದಾರೆ

632
00:33:57,000 --> 00:34:00,000
ಈ ಸ್ಥಳೀಯ ಕಾರ್ಯ ಒಳಗೆ ಎಲ್ಲಾ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಎಂದರೇನು

633
00:34:00,000 --> 00:34:03,000
ನೀವು ಸುಮಾರು ಇರಿ ನೀವು ಕಾಳಜಿವಹಿಸುವ ಎಂದು.

634
00:34:03,000 --> 00:34:07,000
ಈಗ, printf ಆದ್ದರಿಂದ ನನ್ನ ಮುಂದೆ ಕೇವಲ ರೀತಿಯ ಆಗದ, ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸುಮಾರು "ಮುಂದಿನ."

635
00:34:07,000 --> 00:34:10,000
ಈ ಪರಿಸರದಲ್ಲಿ ಇರುವ ಕಾರಣ ನಾವು ವಾಸ್ತವವಾಗಿ ಇದನ್ನು ನೋಡಿದ ಇಲ್ಲ

636
00:34:10,000 --> 00:34:14,000
ಇಲ್ಲಿ ಕೆಳಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು, ಆದರೆ ಇಲ್ಲಿ ಸ್ವಲ್ಪ mangled ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ ಗಮನಿಸುವುದಿಲ್ಲ.

637
00:34:14,000 --> 00:34:17,000
ಆದರೆ, ಅದು ಅಲ್ಲಿ ಪರದೆಯ ಸಂಯೋಜನೆಗಳನ್ನು ಮೀರಿಸಿ ನೋಟೀಸ್ನ್ನು

638
00:34:17,000 --> 00:34:21,000
ಆದ್ದರಿಂದ ಇಲ್ಲಿ ಒಂದು ಪರಿಪೂರ್ಣ ಪ್ರೋಗ್ರಾಂ ಅಲ್ಲ, ಆದರೆ ನಾನು ಯಾವಾಗಲೂ ಸುಮಾರು ಇರಿ ಏಕೆಂದರೆ ಆ ಸರಿಯಾಗಿಯೆ

639
00:34:21,000 --> 00:34:23,000
ನಾನು ಬಯಸಿದರೆ ಮುದ್ರಣ ಬಳಸಿ.

640
00:34:23,000 --> 00:34:26,000
>> ನನ್ನ ಮುಂದಿನ ಮತ್ತೆ ಟೈಪ್ ಅವಕಾಶ, ಮತ್ತು ಈಗ ಇಲ್ಲಿ ಆಸಕ್ತಿಕರ ಭಾಗವಾಗಿದೆ.

641
00:34:26,000 --> 00:34:29,000
ಕಥೆಯಲ್ಲಿ ಈ ಸಮಯದಲ್ಲಿ, ವೈ 2 ಆಗಿದೆ, ಮತ್ತು X 1

642
00:34:29,000 --> 00:34:32,000
ಇಲ್ಲಿ ಸಲಹೆ, ಮತ್ತು ಮತ್ತೆ, ಮಾಹಿತಿ

643
00:34:32,000 --> 00:34:35,000
ನಾನು ಆಜ್ಞೆಯನ್ನು ಬಳಸುವ ಕಾರಣ ಈ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಈಗ ತೋರಿಸುತ್ತಿರುವ ಕಾರಣ

644
00:34:35,000 --> 00:34:40,000
ಪ್ರದರ್ಶನ X ಮತ್ತು ಪ್ರದರ್ಶನ ವೈ, ನಾನು ಮುಂದಿನ ಟೈಪ್ ಆದ್ದರಿಂದ ಕ್ಷಣ

645
00:34:40,000 --> 00:34:43,000
ಸಿದ್ಧಾಂತ x ಮತ್ತು y ರಲ್ಲಿ ವಿನಿಮಯವಾಗಿದೆ ನಾಯಕರಿಗೆ.

646
00:34:43,000 --> 00:34:45,000
ಈಗ, ನಾವು ಈಗಾಗಲೇ ಕೇಸ್ ಹಿಂದಿರುಗಬಹುದೆಂದು ತಿಳಿದಿಲ್ಲ

647
00:34:45,000 --> 00:34:49,000
ಆದರೆ ನಾವು ಆ ನಿಜವಾದ ಎಂಬುದನ್ನು ಊಹಿಸಲು ಆಳವಾದ ಧುಮುಕುವುದಿಲ್ಲ ಹೇಗೆ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ನೋಡುತ್ತಾರೆ.

648
00:34:49,000 --> 00:34:54,000
ದುರದೃಷ್ಟವಶಾತ್ ಮುಂದಿನ, ಮತ್ತು, Y ಇನ್ನೂ 2 ಮತ್ತು X ಇನ್ನೂ 1, ಮತ್ತು ನಾನು ಎಷ್ಟು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.

649
00:34:54,000 --> 00:34:56,000
ಮುದ್ರಣ X, ಮುದ್ರಣ ವೈ.

650
00:34:56,000 --> 00:34:59,000
ವಾಸ್ತವವಾಗಿ, ವಿನಿಮಯ ಯಾವುದೇ ವಾಸ್ತವವಾಗಿ ಸಂಭವಿಸಿತು, ಈ ಮೇಲೆ ಆರಂಭಿಸೋಣ.

651
00:34:59,000 --> 00:35:01,000
ಸ್ಪಷ್ಟವಾಗಿ ಸ್ವಾಪ್ ಮುರಿದಿದೆ.

652
00:35:01,000 --> 00:35:04,000
ಅವರ ಬದಲಿಗೆ ಮತ್ತೊಮ್ಮೆ "ರನ್" ಟೈಪ್ ಲೆಟ್.

653
00:35:04,000 --> 00:35:07,000
ನನಗೆ ಹೌದು ಹೇಳಲು ಅವಕಾಶ, ನಾನು ಆರಂಭದಿಂದಲೂ ಅದನ್ನು ಪುನರಾರಂಭಿಸಿ ಬಯಸುವ, ನಮೂದಿಸಿ.

654
00:35:07,000 --> 00:35:09,000
>> ಈಗ ನಾನು ಮತ್ತೆ ಸಾಲಿನ 18 ನೇ ಆಗಿದ್ದೇನೆ.

655
00:35:09,000 --> 00:35:11,000
ಈಗ x ಮತ್ತು y ಮತ್ತೆ ಕಸ ಮೌಲ್ಯಗಳು ಗಮನಿಸುವುದಿಲ್ಲ.

656
00:35:11,000 --> 00:35:15,000
, ಮುಂದಿನ ಮುಂದಿನ, ಮುಂದಿನ, ಮುಂದಿನ.

657
00:35:15,000 --> 00:35:17,000
ನಾನು ಬೇಸರ ಪಡೆಯಲು ನಾನು ಕೂಡ ಮುಂದಿನ N ಟೈಪ್ ಮಾಡಬಹುದು.

658
00:35:17,000 --> 00:35:21,000
ನೀವು ಅಕ್ಷರಗಳು ಕಡಿಮೆ ಸಂಭವನೀಯ ಸರಣಿಯು ಅದನ್ನು ಮೊಟಕಾದ ಮಾಡಬಹುದು.

659
00:35:21,000 --> 00:35:23,000
ಸ್ವಾಪ್ ಈಗ ಮುರಿದಿದೆ.

660
00:35:23,000 --> 00:35:25,000
ಬದಲಿಗೆ ಮುಂದಿನ ಟೈಪ್ ಆದ್ದರಿಂದ, ರ ಡೈವ್ ಅವಕಾಶ

661
00:35:25,000 --> 00:35:30,000
ಈ ಕಾರ್ಯದ ಒಳಗೆ ಹೆಜ್ಜೆ ನಾನು ಈಗ ನಾನು ಹಂತದ ಟೈಪಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

662
00:35:30,000 --> 00:35:33,000
ನಾನು ಮೂಲಕ ನಡೆದು, ಇದರಿಂದ ನಾನು ಹಂತದ ಹೊಡೆಯಲು ಮತ್ತು ನಂತರ ನಮೂದಿಸಿ ಆದ್ದರಿಂದ.

663
00:35:33,000 --> 00:35:37,000
ಗಮನಿಸಿ ಸಾಲಿನ 36 ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಹೈಲೈಟ್ ಜಿಗಿತಗಳನ್ನು ಕೆಳ ಎಂದು.

664
00:35:37,000 --> 00:35:39,000
ಈಗ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಯಾವುವು?

665
00:35:39,000 --> 00:35:41,000
ಮಾಹಿತಿಯನ್ನು ಸ್ಥಳೀಯರು.

666
00:35:41,000 --> 00:35:43,000
ನಾವು ಸಾಲಿಗೆ ನೆತ್ತಿಗೇರಿದೆ ಮಾಡಿಲ್ಲ ಏಕೆಂದರೆ ಇನ್ನೂ ಏನೂ,

667
00:35:43,000 --> 00:35:47,000
ಆದ್ದರಿಂದ ಅವರ ಮುಂದೆ ಹೋಗಿ ಮತ್ತು ಹೇಳಲು ಅವಕಾಶ "ಮುಂದಿನ."

668
00:35:47,000 --> 00:35:50,000
ಈಗ ನಾವು tmp, ಮುದ್ರಣ tmp ತೋರುತ್ತದೆ.

669
00:35:50,000 --> 00:35:52,000
ಗಾರ್ಬೇಜ್ ಮೌಲ್ಯ, ಬಲ? ನಾನು ಭಾವಿಸುತ್ತೇನೆ.

670
00:35:52,000 --> 00:35:55,000
ಹೇಗೆ ಬಗ್ಗೆ, ಮುದ್ರಣ ಬೌ, 1 ಮತ್ತು 2 ಮುದ್ರಿಸಲು?

671
00:35:55,000 --> 00:35:58,000
ಒಂದು ಕ್ಷಣದಲ್ಲಿ, ತಕ್ಷಣ ನಾನು ಮುಂದಿನ ಮತ್ತೆ ಟೈಪ್

672
00:35:58,000 --> 00:36:02,000
tmp, ಆಶಾದಾಯಕವಾಗಿ, 1 ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಹೋಗುತ್ತದೆ

673
00:36:02,000 --> 00:36:05,000
tmp ಒಂದು ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸಲಾಗುವುದು ಹೋಗುವ ಕಾರಣ.

674
00:36:05,000 --> 00:36:08,000
>> ಈಗ ಒಂದು, ಮುದ್ರಣ ಬೌ ಮುದ್ರಿಸಲು ಮಾಡೋಣವೇ,

675
00:36:08,000 --> 00:36:11,000
ಆದರೆ ಈಗ tmp ಮುದ್ರಿಸಲು, ಮತ್ತು ವಾಸ್ತವವಾಗಿ 1.

676
00:36:11,000 --> 00:36:14,000
ನನ್ನ ಮುಂದಿನ ಮಾಡೋಣ. ನನ್ನ ಮುಂದಿನ ಮಾಡೋಣ.

677
00:36:14,000 --> 00:36:16,000
ನಾನು ಸ್ವಾಪ್ ಕಾರ್ಯ ಮುಕ್ತಾಯಗೊಂಡ.

678
00:36:16,000 --> 00:36:19,000
ನಾನು ಸಾಲು 40 ರಲ್ಲಿ ಒಳಗೆ ಇನ್ನೂ ಆಮ್, ಹಾಗೆ ಅಂತ ಮುದ್ರಿಸಲು ಅವಕಾಶ

679
00:36:19,000 --> 00:36:22,000
ಮುದ್ರಣ ಬೌ, ಮತ್ತು ನಾನು tmp ಏನು ಹೆದರುವುದಿಲ್ಲ.

680
00:36:22,000 --> 00:36:27,000
ಇದು ಒಂದು ಮತ್ತು ಬಿ ವಿನಿಮಯ ಮಾಡಲು ಬಂದಾಗ ಸ್ವಾಪ್ ಸರಿಯಾಗಿದೆ ತೋರುತ್ತಿದೆ.

681
00:36:27,000 --> 00:36:31,000
ಆದರೆ ನಾನು ಈಗ ಮುಂದಿನ ಟೈಪ್ ವೇಳೆ, ನಾನು, ಸಾಲು 25 ಮತ್ತೆ ಜಿಗಿತವನ್ನು

682
00:36:31,000 --> 00:36:34,000
ಮತ್ತು ಸಹಜವಾಗಿ, X ಮತ್ತು ಮುದ್ರಣ ವೈ ನಾನು ರೀತಿಯ ವೇಳೆ

683
00:36:34,000 --> 00:36:38,000
ಅವರು ಇನ್ನೂ ಬದಲಾಗಿಲ್ಲ ಆರ್, ಆದ್ದರಿಂದ ನಾವು ತೊಂದರೆಯನ್ನು ನಿವಾರಿಸಲಾಗಿದೆ ಮಾಡಿಲ್ಲ.

684
00:36:38,000 --> 00:36:41,000
ಆದರೆ ವಿಶ್ಲೇಷಣಾತ್ಮಕವಾಗಿ ಈಗ ಬಹುಶಃ ಈ GDB ಕಾರ್ಯಕ್ರಮ

685
00:36:41,000 --> 00:36:44,000
ನಾವು ಕನಿಷ್ಟ ಗ್ರಹಿಕೆಗೆ ಒಂದು ಹೆಜ್ಜೆ ಹತ್ತಿರಕ್ಕೆ ನೆತ್ತಿಗೇರಿದೆ ನೀವು

686
00:36:44,000 --> 00:36:47,000
ಎಂಬುದನ್ನು ಇಲ್ಲಿ printf ಇರಿಸುವ ಕಸ ನಮ್ಮ ಕೋಡ್ ಮಾಡದೆಯೇ ತಪ್ಪು ವಿಶೇಷವೇನು,

687
00:36:47,000 --> 00:36:50,000
printf ಇಲ್ಲಿ printf ಇಲ್ಲಿ ತದನಂತರ ಮತ್ತೆ ಮತ್ತೆ ಚಾಲನೆಯಲ್ಲಿರುವ

688
00:36:50,000 --> 00:36:52,000
ತಪ್ಪು ವಿಶೇಷವೇನು ಏನೆಂದು ಲೆಕ್ಕಾಚಾರ ಹಾಕಿದ್ದೆ.

689
00:36:52,000 --> 00:36:55,000
>> ನಾನು ಬಿಟ್ಟು ಒಟ್ಟಿಗೆ ಮುಂದೆ ಹೋಗಿ ಈ ಹೊರಗೆ ಬಿಟ್ಟು ಪಡೆಯಲಿದ್ದೇನೆ.

690
00:36:55,000 --> 00:36:57,000
ನಂತರ ಹೇಳಲು ವಿಶೇಷವೇನು, "ಹೇಗಾದರೂ ಕ್ವಿಟ್?" ಹೌದು.

691
00:36:57,000 --> 00:37:00,000
ಈಗ ನಾನು ನನ್ನ ಸಾಮಾನ್ಯ ಪ್ರಾಂಪ್ಟಿನಲ್ಲಿ ಹಿಂದೆ ನಾನು ಮತ್ತು ನಾನು GDB ಬಳಸಿಕೊಂಡು ಮುಗಿಸಿದ್ದೇನೆ.

692
00:37:00,000 --> 00:37:03,000
ಅತ್ತ, ಈ-ತುಐ ಧ್ವಜವನ್ನು ಬಳಸಲು ಅಗತ್ಯವಿಲ್ಲ.

693
00:37:03,000 --> 00:37:07,000
ನೀವು ಅದನ್ನು ಬಿಟ್ಟಿವೆ ವೇಳೆ ವಾಸ್ತವವಾಗಿ, ನೀವು ಮೂಲಭೂತವಾಗಿ ತೆರೆಯ ಕೆಳಭಾಗದ ಅರ್ಧ ಪಡೆಯಿರಿ.

694
00:37:07,000 --> 00:37:11,000
ನಾನು ನಂತರ ಚಲಾಯಿಸಿ ಬ್ರೇಕ್ ಮುಖ್ಯ ಟೈಪ್ ಮತ್ತು ವೇಳೆ

695
00:37:11,000 --> 00:37:15,000
ನಾನು ಇನ್ನೂ ನನ್ನ ಪ್ರೊಗ್ರಾಮನ್ನು, ಆದರೆ ಏನು ಮಾಡುತ್ತಾನೆ ಹೆಚ್ಚು ಪಠ್ಯ ರೂಪದಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ

696
00:37:15,000 --> 00:37:18,000
ಕೇವಲ ಒಂದು ಸಮಯದಲ್ಲಿ ನನಗೆ ಪ್ರಸಕ್ತ ಸಾಲಿನ ಒಂದು ತೋರಿಸುತ್ತವೆ.

697
00:37:18,000 --> 00:37:21,000
-ತುಐ, ಪಠ್ಯ ಬಳಕೆದಾರ ಇಂಟರ್ಫೇಸ್

698
00:37:21,000 --> 00:37:25,000
ನೀವು ಒಮ್ಮೆ, ಬಹುಶಃ ಒಂದು ಬಿಟ್ ಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಸುಲಭ ಇದು ಕಾರ್ಯಕ್ರಮದ ಹೆಚ್ಚು ತೋರಿಸುತ್ತದೆ.

699
00:37:25,000 --> 00:37:27,000
ಆದರೆ ವಾಸ್ತವವಾಗಿ, ನಾನು, ಮುಂದಿನ ಮುಂದಿನ, ಮುಂದಿನ ಮಾಡಬಹುದು

700
00:37:27,000 --> 00:37:30,000
ಮತ್ತು ನಾನು ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಸಾಲನ್ನು ನೋಡಿ ಹೋಗಿ, ಮತ್ತು ನಾನು ನಿಜವಾಗಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ನೋಡಲು ಬಯಸಿದರೆ

701
00:37:30,000 --> 00:37:35,000
ನಾನು ಪಟ್ಟಿಯಲ್ಲಿ ಟೈಪ್ ಮತ್ತು ನೆರೆಯ ರೇಖೆಗಳು ಇಡೀ ಗುಂಪೇ ನೋಡಬಹುದು.

702
00:37:35,000 --> 00:37:39,000
>> ನಾವು ಸಮಸ್ಯೆಯನ್ನು 3 ಹೊಂದಿಸುತ್ತದೆ ನೀವು ವೀಕ್ಷಿಸುವ ಕೇಳಿದ್ದೀರಿ ಒಂದು ವೀಡಿಯೊ ಇಲ್ಲ

703
00:37:39,000 --> 00:37:43,000
ಇದರಲ್ಲಿ ನೇಟ್, GDB ತೊಡಕುಳ್ಳದ್ದಾಗಿರುತ್ತದೆ ಕೆಲವು ಆವರಿಸುತ್ತದೆ

704
00:37:43,000 --> 00:37:46,000
ಮತ್ತು ಈ, ಪ್ರಾಮಾಣಿಕವಾಗಿ, ಆ ವಸ್ತುಗಳ ಒಂದು ಅಲ್ಲಿ ನೀವು ಕೆಲವು ಯಕಃಶ್ಚಿತ್ತಾಗಿರದ ಶೇಕಡಾವಾರು

705
00:37:46,000 --> 00:37:49,000
GDB ಸ್ಪರ್ಶಕ್ಕೆ ಎಂದಿಗೂ, ಮತ್ತು ಒಂದು ಕೆಟ್ಟ ವಿಷಯ ಎಂದು

706
00:37:49,000 --> 00:37:53,000
ಅಕ್ಷರಶಃ ಈ ಸೆಮಿಸ್ಟರ್ ನಂತರ ಹೆಚ್ಚು ಸಮಯ ಕಳೆಯುತ್ತಿದ್ದರು ಕೊನೆಗಾಣಿಸುವ ಏಕೆಂದರೆ

707
00:37:53,000 --> 00:37:56,000
ದೋಷಗಳನ್ನು ಕೆಳಗೆ ಅಟ್ಟಿಸಿಕೊಂಡು ಆಗ ನೀವು ಅರ್ಧದಷ್ಟು ಗಂಟೆ / ಗಂಟೆಗಳ ಇರಿಸಲಾಯಿತು ಎಂದು

708
00:37:56,000 --> 00:38:00,000
ಈ ವಾರ ಮತ್ತು ಮುಂದಿನ ಕಲಿಕೆ GDB ತೃಪ್ತಿ ಪಡೆಯಲು.

709
00:38:00,000 --> 00:38:02,000
Printf ನಿಮ್ಮ ಸ್ನೇಹಿತ.

710
00:38:02,000 --> 00:38:05,000
GDB ಈಗ ನಿಮ್ಮ ಸ್ನೇಹಿತ ಆಗಿರಬೇಕು.

711
00:38:05,000 --> 00:38:08,000
>> GDB ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

712
00:38:08,000 --> 00:38:12,000
ಮತ್ತು ಇಲ್ಲಿ ಅತ್ಯಂತ ಶಕ್ತಿಶಾಲಿ ಮತ್ತು ಉಪಯುಕ್ತ ಆಜ್ಞೆಗಳ ಕೆಲವು ತ್ವರಿತ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.

713
00:38:12,000 --> 00:38:15,000
ಹೌದು. >> ನೀವು ಸ್ಟ್ರಿಂಗ್ ಮುದ್ರಿಸಬಹುದು?

714
00:38:15,000 --> 00:38:17,000
ನೀವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಮುದ್ರಿಸಬಹುದು? ಸಂಪೂರ್ಣ.

715
00:38:17,000 --> 00:38:19,000
ಇದು ಕೇವಲ ಪೂರ್ಣಾಂಕಗಳ ಎಂದು ಹೊಂದಿಲ್ಲ.

716
00:38:19,000 --> 00:38:22,000
ಒಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ರು ಮುದ್ರಣ ರು ಕೇವಲ ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ವೇಳೆ.

717
00:38:22,000 --> 00:38:24,000
ಆ ವಾಕ್ಯವನ್ನು ವೇರಿಯಬಲ್ ಏನು ನಿಮಗೆ ತೋರಿಸುತ್ತದೆ.

718
00:38:24,000 --> 00:38:26,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

719
00:38:26,000 --> 00:38:28,000
ನೀವು ವಿಳಾಸಕ್ಕೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಸ್ವತಃ ನೀಡುತ್ತದೆ.

720
00:38:28,000 --> 00:38:32,000
ನೀವು ಎರಡೂ ತೋರಿಸುತ್ತದೆ.

721
00:38:32,000 --> 00:38:34,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಕೇವಲ ಈ ತುಂಬಾ ತಿಳಿಯಲು ಉತ್ತಮ ಏಕೆಂದರೆ.

722
00:38:34,000 --> 00:38:37,000
Backtrace ಮತ್ತು ಫ್ರೇಮ್, ನನಗೆ ಒಂದು ಕೊನೆಯ ಸಮಯದಲ್ಲಿ ಧುಮುಕುವುದಿಲ್ಲ ಅವಕಾಶ

723
00:38:37,000 --> 00:38:39,000
GDB ಅದೇ ನಿಖರ ಕಾರ್ಯಕ್ರಮ.

724
00:38:39,000 --> 00:38:44,000
ನನಗೆ ಮುಂದುವರಿಯಲು ಮತ್ತು ಪಠ್ಯ ಬಳಕೆದಾರ ಅಂತರಸಂಪರ್ಕ ಆವೃತ್ತಿ ಔಟ್ ಲೆಟ್,

725
00:38:44,000 --> 00:38:46,000
ಮುಖ್ಯ ಮುರಿಯಲು.

726
00:38:46,000 --> 00:38:49,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಮತ್ತೆ ಔಟ್ ಲೆಟ್. ಇಲ್ಲಿ ನಾನು.

727
00:38:49,000 --> 00:38:55,000
ಈಗ, ಮುಂದಿನ ಮುಂದಿನ, ಮುಂದಿನ, ಮುಂದಿನ, ಮುಂದಿನ ಆಗದ, ಹೆಜ್ಜೆ, ನಮೂದಿಸಿ.

728
00:38:55,000 --> 00:39:00,000
>> ಮತ್ತು ಈಗ ನಾನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಸ್ವಾಪ್ ಈಗ ಆಮ್ ಊಹಿಸಿಕೊಳ್ಳಿ ಆದರೆ ನಾನು ಹಾಗೆ ನಾನು "ಡ್ಯಾಮ್, X ಮೌಲ್ಯವನ್ನು ಏನು?"

729
00:39:00,000 --> 00:39:02,000
ನಾನು ಎಂದಿಗೂ X ಸಾಧ್ಯವಿಲ್ಲ.

730
00:39:02,000 --> 00:39:05,000
ಅವರು ಸ್ಕೋಪ್ ಇಲ್ಲ ಏಕೆಂದರೆ ನಾನು ವೈ ಸಾಧ್ಯವಿಲ್ಲ.

731
00:39:05,000 --> 00:39:07,000
ಅವರು ವಿಷಯದಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ ಯಾವುದೇ ಸಮಸ್ಯೆ.

732
00:39:07,000 --> 00:39:09,000
ನಾನು backtrace ಟೈಪ್ ಮಾಡಬಹುದು.

733
00:39:09,000 --> 00:39:13,000
ನನಗೆ ಸಮಯ ಈ ಹಂತದವರೆಗೆ ಮರಣದಂಡನೆ ಕಾರ್ಯಗಳ ಎಲ್ಲಾ ತೋರಿಸುತ್ತದೆ.

734
00:39:13,000 --> 00:39:16,000
ಗಮನಿಸಿ ಪ್ರಮುಖ ಮುಖ್ಯ ಕೆಳಭಾಗದಲ್ಲಿ ಒಂದು, ಸಾಲುಗಳನ್ನು

735
00:39:16,000 --> 00:39:18,000
ಇಲ್ಲಿ ನಮ್ಮ ಚಿತ್ರದ ಕೆಳಭಾಗದಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ.

736
00:39:18,000 --> 00:39:22,000
ಸ್ವಾಪ್ ಸ್ವಾಪ್ ಇಲ್ಲಿ ಮೆಮೊರಿ ಅದನ್ನು ಮೇಲಿನವರೆಗೆ ಜೊತೆ ಇದು ರೇಖೆಗಳ ಮೇಲೆ ಎಂದು ವಾಸ್ತವವಾಗಿ,

737
00:39:22,000 --> 00:39:26,000
ಮತ್ತು ನಾನು ತಾತ್ಕಾಲಿಕವಾಗಿ ಮುಖ್ಯ ಹಿಂದಕ್ಕೆ ಪಡೆಯಲು ಬಯಸಿದರೆ ನಾನು "ಫ್ರೇಮ್." ಹೇಳಬಹುದು

738
00:39:26,000 --> 00:39:30,000
ಯಾವ ನಂಬರ್? ಮುಖ್ಯ ಚೌಕಟ್ಟಿನಲ್ಲಿ # 1.

739
00:39:30,000 --> 00:39:32,000
ನಾನು ಮುಂದೆ ಹೋಗಿ ಮತ್ತು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ "ಫ್ರೇಮ್ 1."

740
00:39:32,000 --> 00:39:36,000
>> ಈಗ ನಾನು ಮುಖ್ಯ ಮತ್ತೆ ನಾನು, ಮತ್ತು ನಾನು X ಮುದ್ರಿಸಬಹುದು, ಮತ್ತು ನಾನು, Y ಮುದ್ರಿಸಬಹುದು

741
00:39:36,000 --> 00:39:40,000
ಆದರೆ ನಾನು ಒಂದು ಅಥವಾ ಬೌ ಮುದ್ರಿಸಲಾಗುವುದಿಲ್ಲ.

742
00:39:40,000 --> 00:39:43,000
ನಾನು ಹೇಳಲು ಆದರೆ ನಾನು, "ಸರಿ, ಒಂದು ನಿಮಿಷ ನಿರೀಕ್ಷಿಸಿ. ಎಲ್ಲಿ ಸ್ವಾಪ್ ಎಂದು?" ಮಾಡಬಹುದು

743
00:39:43,000 --> 00:39:46,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಹೇಳುತ್ತಾರೆ ನೋಡೋಣ "ಫ್ರೇಮ್ 0."

744
00:39:46,000 --> 00:39:48,000
ಈಗ ನಾನು ಬಯಸುತ್ತೇನೆ ಅಲ್ಲಿ ಮತ್ತೆ ನಾನು, ಮತ್ತು ಒಂದು ಪಕ್ಕಕ್ಕೆ ಮಾಹಿತಿ

745
00:39:48,000 --> 00:39:52,000
ನೀವು ನಿಜವಾಗಿಯೂ ಬೇಸರ ಟೈಪಿಂಗ್ ಮುಂದಿನ, ಮುಂದಿನ, ಮುಂದಿನ, ಮುಂದಿನ ಪಡೆಯುತ್ತಿದ್ದೀರಿ ವೇಳೆ ಇತರ ಆಜ್ಞೆಗಳನ್ನು ಕೂಡ ಇಲ್ಲ

746
00:39:52,000 --> 00:39:56,000
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ", ಮುಂದಿನ 10" ವಿಷಯಗಳನ್ನು ಹೇಳಬಹುದು ಮತ್ತು ಮುಂದಿನ 10 ಸಾಲುಗಳ ಮೂಲಕ ಹೆಜ್ಜೆ ಕಾಣಿಸುತ್ತದೆ.

747
00:39:56,000 --> 00:39:59,000
ನೀವು ನಿಜವಾಗಿಯೂ ಮೂಲಕ ಮೆಟ್ಟಿಲು ಜೊತೆ ಆಹಾರ ಯಾವಾಗ "ಮುಂದುವರೆಯಲು" ಬರೆಯಬಹುದು.

748
00:39:59,000 --> 00:40:05,000
ಇನ್ನೊಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹಿಟ್ಸ್ ರವರೆಗೆ ಮುಂದುವರಿಸಲು, ತಡೆಯಿಲ್ಲದೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಾಣಿಸುತ್ತದೆ

749
00:40:05,000 --> 00:40:07,000
ಒಂದು ಆವರ್ತನದಲ್ಲಿ ಅಥವಾ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಕೆಳ.

750
00:40:07,000 --> 00:40:11,000
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಕೊನೆಯಲ್ಲಿ ಮುಂದುವರಿಸಿದರು, ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಗಮಿಸಿದೆ.

751
00:40:11,000 --> 00:40:13,000
ಈ ಒಂದು ಅಲಂಕಾರಿಕ ರೀತಿಯಲ್ಲಿ, ಕೆಳಗಿನ ಪ್ರಕ್ರಿಯೆ.

752
00:40:13,000 --> 00:40:16,000
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಗಮಿಸಿದೆ.

753
00:40:16,000 --> 00:40:24,000
ವೀಡಿಯೊ ಮತ್ತು ಬರಲು ಅಧಿವೇಶನಗಳ ಡೀಬಗ್ ಆ ಮೇಲೆ ಹೆಚ್ಚು.

754
00:40:24,000 --> 00:40:26,000
ಒಂದು ಸಾಕಷ್ಟು ಆಗಿತ್ತು.

755
00:40:26,000 --> 00:40:35,000
ಲೆಟ್ಸ್ ಇಲ್ಲಿ ನಮ್ಮ 5 ನಿಮಿಷಗಳ ಬಿಡುವು, ಮತ್ತು ನಾವು ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮತ್ತು ಫೈಲ್ಗಳೊಂದಿಗೆ ಬರುತ್ತೇವೆ.

756
00:40:35,000 --> 00:40:38,000
>> ನೀವು ಈಗಾಗಲೇ ಈ ವಾರದ pset ಆಗಿ dived ಇದ್ದರೆ

757
00:40:38,000 --> 00:40:41,000
ನೀವು, ನಾವು ವಿತರಣಾ ಕೋಡ್ ಬಳಸುವ ತಿಳಿದಿರುವ ವಿಲ್

758
00:40:41,000 --> 00:40:45,000
ನಾವು ಒಂದು ಆರಂಭದ ಕೆಲವು ಹೊಸ ತಂತ್ರಗಳನ್ನು ನಿಮಗೆ ಒದಗಿಸುವ ಮೂಲ ಕೋಡ್.

759
00:40:45,000 --> 00:40:50,000
ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಾವು, ರಚನೆಯು, struct ಎಂಬ ಈ ಹೊಸ ಕೀವರ್ಡ್ ಪರಿಚಯಿಸಿತು

760
00:40:50,000 --> 00:40:53,000
ಆದ್ದರಿಂದ ನಾವು ರೀತಿಯ ಕಸ್ಟಮೈಸ್ ಅಸ್ಥಿರ ರಚಿಸಬಹುದು.

761
00:40:53,000 --> 00:40:57,000
ನಾವು ಸಹ, ಫೈಲ್ I / O, ಕಡತ ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸಿತು

762
00:40:57,000 --> 00:41:00,000
ಈ ನಾವು ರಾಜ್ಯದ ಉಳಿಸಲು ಇದರಿಂದ ಆಗಿದೆ

763
00:41:00,000 --> 00:41:03,000
ನಿಮ್ಮ ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಮಂಡಳಿಯ ಡಿಸ್ಕ್ ಒಂದು ಕಡತಕ್ಕೆ

764
00:41:03,000 --> 00:41:06,000
ಇತರ ಫೆಲೋಗಳು ಮತ್ತು ನಾನು ಅರ್ಥ ಇದರಿಂದ

765
00:41:06,000 --> 00:41:09,000
ಯಾವ ಕೈಯಿಂದ ಆಡಲು ಮಾಡದೆಯೇ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಒಳಗೆ ವಿಶೇಷವೇನು

766
00:41:09,000 --> 00:41:11,000
ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಆಟಗಳನ್ನು ಡಜನ್ಗಟ್ಟಲೆ.

767
00:41:11,000 --> 00:41:13,000
ನಾವು ಹೆಚ್ಚು automatedly ಈ ಮಾಡಬಹುದು.

768
00:41:13,000 --> 00:41:18,000
>> ಒಂದು struct ಈ ಕಲ್ಪನೆಯನ್ನು ಸಾಕಷ್ಟು ಬಲವಾದ ಸಮಸ್ಯೆಯನ್ನು ಬಗೆಹರಿಸುವ.

769
00:41:18,000 --> 00:41:21,000
ನಾವು ಕೆಲವು ಯೋಜನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಬಯಸುವ ಪಕ್ಷ

770
00:41:21,000 --> 00:41:25,000
ಅದು ಹೇಗಾದರೂ ಮಾಡಿ, ವಿದ್ಯಾರ್ಥಿಗಳು ಮಾಹಿತಿಯನ್ನು ಟ್ರ್ಯಾಕ್ನಲ್ಲಿರಿಸಿಕೊಳ್ಳುತ್ತಾರೆ

771
00:41:25,000 --> 00:41:28,000
ಮತ್ತು ವಿದ್ಯಾರ್ಥಿಗಳು, ಉದಾಹರಣೆಗೆ, ಒಂದು ಹೆಸರು ID ಅನ್ನು ಹೊಂದಿರಬಹುದು

772
00:41:28,000 --> 00:41:31,000
ಮತ್ತು ಹಾರ್ವರ್ಡ್ ಒಂದು ಸ್ಥಳದಲ್ಲಿ ಒಂದು ಮನೆ, ಆದ್ದರಿಂದ ಈ ಮಾಹಿತಿಯನ್ನು 3 ಕಾಯಿಗಳಾಗಿವೆ

773
00:41:31,000 --> 00:41:34,000
ನಾವು ಸುಮಾರು ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ, ಆದ್ದರಿಂದ ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಪ್ರೋಗ್ರಾಂ ಬರೆಯಲು ಶುರು ಮಾಡೋಣ,

774
00:41:34,000 --> 00:41:38,000
stdio.h ಸೇರಿವೆ.

775
00:41:38,000 --> 00:41:42,000
ನನಗೆ cs50.h. ಸೇರಿವೆ ಮಾಡೋಣ

776
00:41:42,000 --> 00:41:44,000
ತದನಂತರ ನನ್ನ ಮುಖ್ಯ ಕಾರ್ಯವನ್ನು ಆರಂಭಿಸಲು.

777
00:41:44,000 --> 00:41:46,000
ನಾನು ಯಾವುದೇ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಗ್ಗೆ ತಲೆಕೆಡಿಸಿಕೊಳ್ಳುತ್ತಿರಲಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ

778
00:41:46,000 --> 00:41:49,000
ಮತ್ತು ಇಲ್ಲಿ ನಾನು ವಿದ್ಯಾರ್ಥಿ ಬೇಕು, ಆದ್ದರಿಂದ ನಾನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

779
00:41:49,000 --> 00:41:54,000
ವಿದ್ಯಾರ್ಥಿ ಒಂದು ಹೆಸರನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ನಾನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ "ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು."

780
00:41:54,000 --> 00:41:59,000
ಆಗ ನಾನು, ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಕೂಡ, ಆದ್ದರಿಂದ ಇಂಟ್ ಐಡಿ ಒಂದು ID ಯನ್ನು ಹೊಂದಿದೆ ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

781
00:41:59,000 --> 00:42:03,000
ಮತ್ತು ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಒಂದು ಮನೆ ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ನಾನು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ "ಸ್ಟ್ರಿಂಗ್ ಮನೆ."

782
00:42:03,000 --> 00:42:06,000
ನಂತರ ನಾನು ಈ ರೀತಿಯ ಹೆಚ್ಚು ಸರಿಯಾಗಿ ಈ ಸ್ವಲ್ಪ ಆದೇಶ ಮಾಡುತ್ತೇವೆ.

783
00:42:06,000 --> 00:42:11,000
ಸರಿ, ಈಗ ನಾನು, "ಒಂದು ವಿದ್ಯಾರ್ಥಿ." ಇದು ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿನಿಧಿಸಲು 3 ಅಸ್ಥಿರ ಹೊಂದಿವೆ

784
00:42:11,000 --> 00:42:15,000
>> ಮತ್ತು ಈಗ ನಾನು ಈ ಮೌಲ್ಯಗಳನ್ನು ಜನಪ್ರಿಯಗೊಳಿಸುವುದಕ್ಕೆ ಬಯಸುವ, ಹಾಗಾಗಿ ನನಗೆ ಸ್ವಲ್ಪ ಮುಂದೆ ಹೋಗಿ ಮತ್ತು ಹೇಳಲು ಅವಕಾಶ

785
00:42:15,000 --> 00:42:18,000
"ಐಡಿ = 123."

786
00:42:18,000 --> 00:42:21,000
ಹೆಸರು ಡೇವಿಡ್ ಕಾಣುವುದು ಇದೆ.

787
00:42:21,000 --> 00:42:24,000
ಲೆಟ್ಸ್ ಮನೆ, ಮ್ಯಾಥರ್ ಕಾಣುವುದು ಹೇಳುತ್ತಾರೆ

788
00:42:24,000 --> 00:42:31,000
ತದನಂತರ ನಾನು ("% s, ಕ್ರಮವಿಲ್ಲದ printf ರೀತಿಯ ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ

789
00:42:31,000 --> 00:42:37,000
ಇದರ ID% d ಆಗಿದೆ,% s ನಲ್ಲಿ ವಾಸಿಸುತ್ತಾರೆ.

790
00:42:37,000 --> 00:42:41,000
ಈಗ, ನಾನು, ಇಲ್ಲಿ ಪ್ಲಗ್ ಇತರ ನಂತರ ಒಂದು ಏನು ಬಯಸುತ್ತೀರಿ?

791
00:42:41,000 --> 00:42:47,000
ಹೆಸರು, ಐಡಿ, ಮನೆ; ರಿಟರ್ನ್ 0.

792
00:42:47,000 --> 00:42:50,000
ಸರಿ, ಹೊರತು ನಾನು ಎಲ್ಲೋ ಇಲ್ಲಿ ಸ್ಕ್ರೆವೆದ್

793
00:42:50,000 --> 00:42:54,000
ನಾವು ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ ಒಂದು ಒಳ್ಳೆಯ ಪ್ರೋಗ್ರಾಂ ಭಾವಿಸುತ್ತೇನೆ.

794
00:42:54,000 --> 00:42:57,000
ಸಹಜವಾಗಿ, ಈ ಎಲ್ಲ ಆಸಕ್ತಿಕರ ಅಲ್ಲ. ನಾನು 2 ವಿದ್ಯಾರ್ಥಿಗಳು ಬೇಕು ವೇಳೆ?

795
00:42:57,000 --> 00:42:59,000
ಯಾವುದೇ ದೊಡ್ಡ ಒಪ್ಪಂದ ಆ. ನಾನು 2 ಜನರು ಬೆಂಬಲಿಸುತ್ತದೆ.

796
00:42:59,000 --> 00:43:03,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಹೈಲೈಟ್ ಮತ್ತು ಇಲ್ಲಿ ಕೆಳಗೆ ಹೋಗಿ ನೋಡೋಣ,

797
00:43:03,000 --> 00:43:09,000
ಮತ್ತು ನಾನು ಕಿರ್ಕ್ಲ್ಯಾಂಡ್ ವಾಸಿಸುವ ರಾಬ್ ನಂತಹ ಯಾರಾದರೂ "ಐಡಿ = 456" ಹೇಳಬಹುದು.

798
00:43:09,000 --> 00:43:12,000
>> ಸರಿ, ನಿರೀಕ್ಷಿಸಿ, ಆದರೆ ನಾನು ಈ ಒಂದೇ ಕರೆ ಸಾಧ್ಯವಿಲ್ಲ

799
00:43:12,000 --> 00:43:15,000
ಮತ್ತು ನಾನು ಈ ನಕಲಿಸಿ ಮಾಡಲಿಕ್ಕೆ ನಾನು ಕಾಣುತ್ತದೆ,

800
00:43:15,000 --> 00:43:19,000
ಆದ್ದರಿಂದ ನನಗೆ ಈ ಡೇವಿಡ್ ಅವರ ಅಸ್ಥಿರ ಎಂಬುದನ್ನು ಹೇಳಲು ಅವಕಾಶ

801
00:43:19,000 --> 00:43:23,000
ಮತ್ತು ನನಗೆ ರಾಬ್ ಈ ಕೆಲವು ಪ್ರತಿಗಳನ್ನು ಪಡೆಯಲು ಅವಕಾಶ.

802
00:43:23,000 --> 00:43:27,000
ನಾವು ಈ ರಾಬ್ ನ ಕರೆ ಮಾಡುತ್ತೇವೆ ಆದರೆ ಈಗ ಕೆಲಸಕ್ಕೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ

803
00:43:27,000 --> 00:43:33,000
ನಾನು-ನಿರೀಕ್ಷಿಸಿ ಏಕೆಂದರೆ, ಅವರ NAME1 ಮತ್ತು house1, id1 ನನ್ನನ್ನು ಬದಲಾಯಿಸಲು ಅವಕಾಶ.

804
00:43:33,000 --> 00:43:35,000
ರಾಬ್, 2 2 ಆಗಿರುತ್ತದೆ.

805
00:43:35,000 --> 00:43:42,000
ನಾನು ಇಲ್ಲಿ, ಇಲ್ಲಿ, ಇಲ್ಲಿ, ಇಲ್ಲಿ, ಇಲ್ಲಿ, ಇಲ್ಲಿ ಈ ಬದಲಾವಣೆ ಮಾಡಲೇಬೇಕು.

806
00:43:42,000 --> 00:43:45,000
ನಿರೀಕ್ಷಿಸಿ, ಏನು ಟಾಮಿ ಬಗ್ಗೆ? ಮತ್ತೆ ಹೀಗೆ ನೋಡೋಣ.

807
00:43:45,000 --> 00:43:49,000
ನೀವು ಇನ್ನೂ ಈ ಮಾಡುವ ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ ಭಾವಿಸುತ್ತೇನೆ ನಿಸ್ಸಂಶಯವಾಗಿ ವೇಳೆ, ಇದು, ಅಲ್ಲ

808
00:43:49,000 --> 00:43:52,000
ಆದ್ದರಿಂದ ನಕಲಿಸಿ / ಕೆಟ್ಟ ಅಂಟಿಸಿ.

809
00:43:52,000 --> 00:43:55,000
ಆದರೆ ಒಂದು ವಾರದ ಹಿಂದೆ ಈ ಪರಿಹರಿಸಬಹುದು.

810
00:43:55,000 --> 00:43:59,000
>> ನಾವು ಅದೇ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಅನೇಕ ವಿಷಯಗಳನ್ನು ಹೊಂದಬೇಕೆಂಬ ಆಸೆ ನಮ್ಮ ಪರಿಹಾರ ಏನು?

811
00:43:59,000 --> 00:44:01,000
[ವಿದ್ಯಾರ್ಥಿಗಳು] ಒಂದು ಸರಣಿ.

812
00:44:01,000 --> 00:44:03,000
ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಆದ್ದರಿಂದ ಈ ಸ್ವಚ್ಛಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.

813
00:44:03,000 --> 00:44:07,000
ನನ್ನ ಮೇಲೆ ನನಗೆ ಕೆಲವು ಅವಕಾಶ, ಮತ್ತು ನನ್ನ ಬದಲಿಗೆ ಇಲ್ಲಿ ಇದನ್ನು ಬಿಡೋಣ.

814
00:44:07,000 --> 00:44:12,000
ಈ ಜನರು ಕರೆ ಮಾಡುತ್ತೇವೆ, ಮತ್ತು ಬದಲಿಗೆ ನಾನು ", ಇಂಟ್ ಐಡಿಗಳನ್ನು" ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

815
00:44:12,000 --> 00:44:14,000
ಮತ್ತು ನಾನು ಈಗ ನಮಗೆ 3 ಬೆಂಬಲಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

816
00:44:14,000 --> 00:44:18,000
ನಾನು, ", ಸ್ಟ್ರಿಂಗ್ ಹೆಸರುಗಳು" ಹೇಳಲು ಮತ್ತು ನಾವು 3 ಬೆಂಬಲ ವಿಲ್ ಪಡೆಯಲಿದ್ದೇನೆ

817
00:44:18,000 --> 00:44:22,000
ಮತ್ತು ನಂತರ ನಾನು ", ಸ್ಟ್ರಿಂಗ್ ಮನೆ" ಹೇಳಲು ಮತ್ತು ನಾವು 3 ಬೆಂಬಲಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಪಡೆಯಲಿದ್ದೇನೆ.

818
00:44:22,000 --> 00:44:26,000
ಈಗ ಇಲ್ಲಿ ಬದಲಿಗೆ ಡೇವಿಡ್ ತನ್ನ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಪಡೆಯುವ ರಲ್ಲಿ

819
00:44:26,000 --> 00:44:28,000
ನಾವು ಆ ತೊಡೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ.

820
00:44:28,000 --> 00:44:30,000
ನಾವು ಈ ಸ್ವಚ್ಛಗೊಳಿಸುವ ನೀವು ಉತ್ತಮ ಭಾವಿಸುತ್ತಾನೆ.

821
00:44:30,000 --> 00:44:35,000
ನಾನು ನಂತರ ಡೇವಿಡ್ [0] ಮತ್ತು ಹೆಸರುಗಳು [0] ಎಂದು ಹೋಗುತ್ತದೆ ಹೇಳಬಹುದು

822
00:44:35,000 --> 00:44:38,000
ಮತ್ತು ಮನೆ [0].

823
00:44:38,000 --> 00:44:41,000
ಮತ್ತು ನಾವು ಇದೇ ಈ ಮೇಲೆ ಉಳಿಸಬಹುದು ರಾಬ್.

824
00:44:41,000 --> 00:44:46,000
ನ ಈ ಕೆಳಗೆ ಇಲ್ಲಿ ಪುಟ್ ಲೆಟ್, ಆದ್ದರಿಂದ ಅವರು ನಿರಂಕುಶವಾಗಿ ಐಡಿಗಳನ್ನು [1] ಎಂದು ವಿಶೇಷವೇನು.

825
00:44:46,000 --> 00:44:50,000
ಅವರು ಹೆಸರುಗಳು ಎಂದು ವಿಶೇಷವೇನು [1],

826
00:44:50,000 --> 00:44:53,000
ನಂತರ ಕೊನೆಯದಾಗಿ, ಮನೆ [1].

827
00:44:53,000 --> 00:44:57,000
>> , ಇನ್ನೂ ಸ್ವಲ್ಪ ಬಳಲಿಕೆ, ಮತ್ತು ಈಗ ನಾನು ಈ ಕುರಿತು ಲೆಕ್ಕಾಚಾರ ಮಾಡಬೇಕು

828
00:44:57,000 --> 00:45:03,000
ಹಾಗೆ ಹೇಳಿ ನೋಡೋಣ "ಹೆಸರುಗಳು [0], ಐಡಿ [0], ಮನೆ [0]

829
00:45:03,000 --> 00:45:06,000
ಮತ್ತು ಅವರ ಈ pluralize ಅವಕಾಶ.

830
00:45:06,000 --> 00:45:09,000
ಐಡಿಗಳು, ಐಡಿಗಳನ್ನು, ಐಡಿಗಳನ್ನು.

831
00:45:09,000 --> 00:45:12,000
ಮತ್ತೆ, ನಾನು ಮಾಡುತ್ತಿರುವೆ, ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾನು ಈಗಾಗಲೇ, ಮತ್ತೆ ಅಂಟಿಸಿ / ನಕಲಿಸಿ ಆಶ್ರಯಿಸಿರುವ ನಾನು

832
00:45:12,000 --> 00:45:14,000
ಆದ್ದರಿಂದ ಆಡ್ಸ್ ಇನ್ನೊಂದು ದ್ರಾವಣವನ್ನು ಇಲ್ಲಿ ಯ.

833
00:45:14,000 --> 00:45:18,000
ಪ್ರಾಯಶಃ ನಾನು ಆ ರೀತಿಯ ಒಂದು ಲೂಪ್ ಅಥವಾ ಏನೋ ಜೊತೆ ಮತ್ತಷ್ಟು ಈ ಸ್ವಚ್ಛಗೊಳಿಸಲು ಮಾಡಬಹುದು

834
00:45:18,000 --> 00:45:21,000
ಆದ್ದರಿಂದ ಸಣ್ಣ ರಲ್ಲಿ, ಇದು ಸ್ವಲ್ಪ ಉತ್ತಮ ಆದರೆ ಇನ್ನೂ ಭಾಸವಾಗುತ್ತಿದೆ

835
00:45:21,000 --> 00:45:24,000
ನಾನು ಅಂಟಿಸಿ / ನಕಲಿಸಿ ಆಶ್ರಯಿಸಿರುವ ನಾನು, ಆದರೆ ಈ ಸಹ, ನಾನು ಹಕ್ಕು

836
00:45:24,000 --> 00:45:27,000
ನಿಜವಾಗಿಯೂ ಮೂಲಭೂತವಾಗಿ ಬಲ ಪರಿಹಾರ ಏಕೆಂದರೆ

837
00:45:27,000 --> 00:45:29,000
ಕೆಲವೊಮ್ಮೆ ನಾವು ನಿರ್ಧರಿಸಲು ನೀವು ಯಾವ ಗೊತ್ತಾ?

838
00:45:29,000 --> 00:45:32,000
ನಾವು ಡೇವಿಡ್ ಮತ್ತು ರಾಬ್ ಇಮೇಲ್ ವಿಳಾಸಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ನಡೆಯಬೇಕಾಗಿತ್ತು

839
00:45:32,000 --> 00:45:34,000
ಮತ್ತು ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಯಾರ.

840
00:45:34,000 --> 00:45:36,000
ನಾವು ಫೋನ್ ಸಂಖ್ಯೆಗಳು ಸಂಗ್ರಹಿಸಲು ಮಾಡಬೇಕು.

841
00:45:36,000 --> 00:45:39,000
ನಾವು ತುರ್ತು ಸಂಪರ್ಕ ಸಂಖ್ಯೆಗಳು ಸಂಗ್ರಹಿಸಲು ಮಾಡಬೇಕು.

842
00:45:39,000 --> 00:45:41,000
ನಾವು ಶೇಖರಿಸಿಡಲು ಬಯಸುವ ಡೇಟಾವನ್ನು ಈ ತುಂಡುಗಳನ್ನು

843
00:45:41,000 --> 00:45:43,000
ಆದ್ದರಿಂದ ಹೇಗೆ ನೀವು ಮಾಡುತ್ತಿರುವ ಬಗ್ಗೆ ಹೋಗಲಿ?

844
00:45:43,000 --> 00:45:46,000
>> ನೀವು ಮೇಲ್ಭಾಗದಲ್ಲಿ ಇನ್ನೊಂದು ಸರಣಿ ಘೋಷಿಸಿದ, ಮತ್ತು ನಂತರ ನೀವು ಕೈಯಾರೆ ಸೇರಿಸಿ

845
00:45:46,000 --> 00:45:49,000
ಒಂದು ಇಮೇಲ್ ವಿಳಾಸಕ್ಕೆ [0], ಇಮೇಲ್ ವಿಳಾಸಕ್ಕೆ [1]

846
00:45:49,000 --> 00:45:51,000
ಡೇವಿಡ್ ಮತ್ತು ರಾಬ್ ಮತ್ತು ಇತ್ಯಾದಿ.

847
00:45:51,000 --> 00:45:56,000
ಆದರೆ ಈ ವಿನ್ಯಾಸದ ಆಧಾರವಾಗಿರುವ ಕೇವಲ ಒಂದು ಊಹೆ ನಿಜವಾಗಿಯೂ ಇಲ್ಲ

848
00:45:56,000 --> 00:45:59,000
ನಾನು ತಿಳಿಯಲು ಮರ್ಯಾದೆ ಬಳಸಿಕೊಂಡು ನಾನು

849
00:45:59,000 --> 00:46:03,000
[I] ಹಲವಾರು ಸರಣಿಗಳನ್ನು ಪ್ರತಿ

850
00:46:03,000 --> 00:46:06,000
ಕೇವಲ ಆದ್ದರಿಂದ, ಅದೇ ವ್ಯಕ್ತಿಯನ್ನು ಸೂಚಿಸಲು ಸಂಭವಿಸುತ್ತದೆ

851
00:46:06,000 --> 00:46:10,000
ಆದ್ದರಿಂದ [0] ಐಡಿಗಳನ್ನು ನಲ್ಲಿ 123, ಆಗಿದೆ

852
00:46:10,000 --> 00:46:13,000
ಮತ್ತು ನಾನು ಆ ಹೆಸರುಗಳನ್ನು ಹೊಂದಲು ಪಡೆಯಲಿದ್ದೇನೆ [0]

853
00:46:13,000 --> 00:46:16,000
ಅದೇ ವ್ಯಕ್ತಿಯ ಹೆಸರು ಮತ್ತು ಮನೆ [0]

854
00:46:16,000 --> 00:46:21,000
ನಾನು ರಚಿಸಿದ ವಿವಿಧ ಸಾಲುಗಳು ಎಲ್ಲಾ ಅದೇ ವ್ಯಕ್ತಿಯ ಮನೆ ಇತ್ಯಾದಿ ಹೊಂದಿದೆ.

855
00:46:21,000 --> 00:46:24,000
ಆದರೆ ಯಾವುದೇ ಮೂಲಭೂತ ಸಂಪರ್ಕ ಇಲ್ಲ ಎಂದು ಗಮನಕ್ಕೆ

856
00:46:24,000 --> 00:46:27,000
ಮಾಹಿತಿಯನ್ನು, ಐಡಿ, ಹೆಸರು ಮತ್ತು ಮನೆಯ ಆ 3 ತುಣುಕುಗಳ ಪೈಕಿ,

857
00:46:27,000 --> 00:46:32,000
ನಾವು ಈ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಮಾದರಿ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಘಟಕದ ಸಾಲುಗಳು ಇಲ್ಲ ಕೂಡ.

858
00:46:32,000 --> 00:46:35,000
ಅರೆಸ್ ಈ ಮಾಡುವ ಈ ಆಯೋಜಿತ ಮಾರ್ಗವಾಗಿದೆ.

859
00:46:35,000 --> 00:46:38,000
ನಾವು ನಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಮಾದರಿ ಯಾವ ವ್ಯಕ್ತಿ

860
00:46:38,000 --> 00:46:41,000
ಡೇವಿಡ್, ಇದು ಒಳಗೆ ರಾಬ್ ಒಂದು ವ್ಯಕ್ತಿಗಳಂತೆ

861
00:46:41,000 --> 00:46:46,000
ಅಥವಾ ಕೋಶೀಕರಿಸುವಿಕೆಯ ಒಂದು ಹೆಸರು ಹಾಗು ID ಮತ್ತು ಒಂದು ಮನೆ.

862
00:46:46,000 --> 00:46:49,000
>> ನಾವು ಹೇಗಾದರೂ ಸುತ್ತುವರಿಯುವಿಕೆ ಈ ಕಲ್ಪನೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಬಹುದು

863
00:46:49,000 --> 00:46:52,000
ವ್ಯಕ್ತಿಯ ID ಅನ್ನು, ಒಂದು ಹೆಸರು ಮತ್ತು ಒಂದು ಮನೆಯನ್ನು ಹೊಂದಿದ್ದು ಆ ಮೂಲಕ

864
00:46:52,000 --> 00:46:55,000
ಮತ್ತು ನಿಜವಾಗಿಯೂ ಈ ಹ್ಯಾಕ್ ಅವಲಂಬಿಸಬೇಕಾಯಿತು ಅಲ್ಲ ಆ ಮೂಲಕ ನಾವು

865
00:46:55,000 --> 00:46:58,000
ಎಂದು ಬ್ರಾಕೆಟ್ ಏನೋ ನಂಬಿಕೆ

866
00:46:58,000 --> 00:47:02,000
ಈ ಭಿನ್ನಜಾತಿಯ ಆಯ್ರೆಗಳ ಪ್ರತಿ ಅದೇ ಮಾನವ ಘಟಕದ ಸೂಚಿಸುತ್ತದೆ?

867
00:47:02,000 --> 00:47:04,000
ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ಮಾಡಬಹುದು.

868
00:47:04,000 --> 00:47:08,000
ನನಗೆ ಈಗ ಮೇಲಿನ ಮುಖ್ಯ ಹೋಗಿ, ಮತ್ತು ನನ್ನ ಸ್ವಂತ ಅಕ್ಷಾಂಶ ರೀತಿಯ ರಚಿಸಲು ಬಿಡೋಣ

869
00:47:08,000 --> 00:47:10,000
ಮೊದಲ ಬಾರಿಗೆ ನಿಜವಾಗಿ ಕಾಲ.

870
00:47:10,000 --> 00:47:14,000
ನಾವು, ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಈ ತಂತ್ರವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ

871
00:47:14,000 --> 00:47:17,000
ಆದರೆ ಇಲ್ಲಿ ನಾನು, ಮುಂದುವರೆಯುತ್ತದೆ ಮತ್ತು ಒಂದು ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ರಚಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

872
00:47:17,000 --> 00:47:19,000
ಮತ್ತು ನೀವು ಏನು, ನಾನು, ಇದು ವಿದ್ಯಾರ್ಥಿ ಅಥವಾ ವ್ಯಕ್ತಿಯ ಕರೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ ತಿಳಿದಿದೆ

873
00:47:19,000 --> 00:47:23,000
ಮತ್ತು ನಾನು ಒಂದು ರೀತಿಯ ವ್ಯಾಖ್ಯಾನಿಸಲು ಫಾರ್ typedef ಬಳಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

874
00:47:23,000 --> 00:47:25,000
ನಾನು, ಈ ಒಂದು ರಚನೆ ಎಂದು ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

875
00:47:25,000 --> 00:47:29,000
ತದನಂತರ ಈ ರಚನೆ, ರೀತಿಯ ವಿದ್ಯಾರ್ಥಿ ಎಂದು, ನಾವು ಹೇಳುತ್ತೇನೆ ಹೋಗುತ್ತದೆ

876
00:47:29,000 --> 00:47:31,000
ನನಗೆ ಈಗ ದಿನಾಂಕ ಸ್ವಲ್ಪ ಕೂಡ ಆದರೂ.

877
00:47:31,000 --> 00:47:33,000
ನಾವು "ಇಂಟ್ ಐಡಿ." ಹೇಳುತ್ತೇನೆ

878
00:47:33,000 --> 00:47:35,000
ನಾವು "ಸ್ಟ್ರಿಂಗ್ ಹೆಸರು." ಹೇಳುತ್ತೇನೆ

879
00:47:35,000 --> 00:47:37,000
ನಂತರ ನಾವು "ಸ್ಟ್ರಿಂಗ್ ಮನೆ," ಹೇಳುತ್ತೇನೆ

880
00:47:37,000 --> 00:47:40,000
ಆದ್ದರಿಂದ ಈಗ ಕೋಡ್ ಈ ಕೆಲವು ಸಾಲುಗಳು ಕೊನೆಯಲ್ಲಿ

881
00:47:40,000 --> 00:47:45,000
ನಾನು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಎಂದು ಖಣಿಲು ಹೇಳಿಕೊಟ್ಟ

882
00:47:45,000 --> 00:47:49,000
ತಂತಿಗಳನ್ನು ಜೊತೆಗೆ ints ಜೊತೆಗೆ ಒಂದು ಮಾಹಿತಿ ಪ್ರಕಾರ, ಜೊತೆಗೆ ಫ್ಲೋಟ್ಗಳು ಜೊತೆಗೆ, ಡಬಲ್ಸ್.

883
00:47:49,000 --> 00:47:54,000
>> ಟೈಮ್ ಲೈನ್ 11 ಈ ಕ್ಷಣದ ಮಾಹಿತಿ, ವಿದ್ಯಾರ್ಥಿಗಳು ಎಂಬ ಹೊಸ ರೀತಿಯ ಮಾಹಿತಿ, ಈಗ ಇಲ್ಲ

884
00:47:54,000 --> 00:47:58,000
ಮತ್ತು ಈಗ, ಎಲ್ಲಾದರೂ ನಾನು ಬಯಸುವ ವಿದ್ಯಾರ್ಥಿ ವೇರಿಯಬಲ್ ಘೋಷಿಸಬಹುದು

885
00:47:58,000 --> 00:48:01,000
ಆದ್ದರಿಂದ ನನ್ನನ್ನು ಜನರು ಇಲ್ಲಿ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಅವಕಾಶ.

886
00:48:01,000 --> 00:48:05,000
ಈಗ ನಾನು ಈ ತೊಡೆದುಹಾಕಲು, ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಡೇವಿಡ್ ಮತ್ತೆ ಕೆಳಗೆ ಹೋಗಿ

887
00:48:05,000 --> 00:48:10,000
ಮತ್ತು ಡೇವಿಡ್ ನಾನು ವಾಸ್ತವವಾಗಿ ಆ ಡೇವಿಡ್, ಹೇಳಬಹುದು

888
00:48:10,000 --> 00:48:13,000
ನಾವು ಅಕ್ಷರಶಃ, ನನ್ನ ನಂತರ ವೇರಿಯಬಲ್ ಹೆಸರಿಸಬಹುದು

889
00:48:13,000 --> 00:48:16,000
ರೀತಿಯ ವಿದ್ಯಾರ್ಥಿ ಎಂದು ಹೋಗುತ್ತದೆ.

890
00:48:16,000 --> 00:48:18,000
ಈ ಸ್ವಲ್ಪ ವಿಯರ್ಡ್ ನೋಡಲು ಇರಬಹುದು, ಆದರೆ ಈ ಎಲ್ಲಾ ವಿಭಿನ್ನ ಅಲ್ಲ

891
00:48:18,000 --> 00:48:22,000
ಒಂದು ಇಂಟ್ ಅಥವಾ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಒಂದು ಫ್ಲೋಟ್ ಎಂದು ಏನೋ ಘೋಷಿಸಿದ್ದರ.

892
00:48:22,000 --> 00:48:24,000
ಅದು ಹಾಗೆ, ಈಗ ವಿದ್ಯಾರ್ಥಿ ಎಂದು ಸಂಭವಿಸಿದರೆ

893
00:48:24,000 --> 00:48:28,000
ಮತ್ತು ನಾನು ಈ ರಚನೆಯ ಒಳಗೆ ಏನೋ ಸೇರಿಸಿಕೊಳ್ಳಬೇಕು ಅಂದುಕೊಂಡರೆ

894
00:48:28,000 --> 00:48:31,000
ನಾನು ಈಗ ವಾಕ್ಯ ಹೊಸ ತುಂಡು ಬಳಸಲು, ಆದರೆ ಇದು ಬಹಳ ಸರಳ ಇಲ್ಲಿದೆ

895
00:48:31,000 --> 00:48:39,000
david.id = 123, ರಾಜಧಾನಿ ಡಿ david.name = "ಡೇವಿಡ್",

896
00:48:39,000 --> 00:48:42,000
ಮತ್ತು david.house = "ಮ್ಯಾಥರ್,"

897
00:48:42,000 --> 00:48:46,000
ಮತ್ತು ಈಗ ನಾನು ಇಲ್ಲಿ ಈ ವಿಷಯವನ್ನು ತೊಡೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ.

898
00:48:46,000 --> 00:48:51,000
ನಾವು ಈಗ ನಿಜವಾಗಿಯೂ ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮರುವಿನ್ಯಾಸಗೊಳಿಸಿದ್ದೇವೆ ಎಚ್ಚರಿಕೆ

899
00:48:51,000 --> 00:48:54,000
ಎಂದು ಈಗ ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನೈಜ ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ.

900
00:48:54,000 --> 00:48:57,000
>> ವ್ಯಕ್ತಿಯ ಅಥವಾ ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಒಂದು ನೈಜ ಪ್ರಪಂಚದ ಕಲ್ಪನೆ ಇಲ್ಲ.

901
00:48:57,000 --> 00:49:02,000
ಇಲ್ಲಿ ನಾವು ಈಗ ವ್ಯಕ್ತಿಯ ಅಥವಾ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿ ಒಂದು ವಿದ್ಯಾರ್ಥಿ ಒಂದು ಸಿ ಆವೃತ್ತಿ ಹೊಂದಿವೆ.

902
00:49:02,000 --> 00:49:05,000
ಆ ವ್ಯಕ್ತಿಯ ಒಳಗೆ ಈ ಸಂಬಂಧಿತ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿವೆ

903
00:49:05,000 --> 00:49:10,000
ID ಯನ್ನು, ಹೆಸರು ಮತ್ತು ಮನೆ, ಆದ್ದರಿಂದ ರಾಬ್ ಮೂಲಭೂತವಾಗಿ ಕೆಳಗೆ ಇಲ್ಲಿ ಒಂದೇ ಆಗುತ್ತದೆ,

904
00:49:10,000 --> 00:49:14,000
, ವಿದ್ಯಾರ್ಥಿ ರಾಬ್ ಆದ್ದರಿಂದ, ಮತ್ತು ಈಗ = 456 rob.id

905
00:49:14,000 --> 00:49:17,000
rob.name = "ರಾಬ್."

906
00:49:17,000 --> 00:49:20,000
ವೇರಿಯಬಲ್ ರಾಬ್ ಎಂಬ ಅಂಶವನ್ನು ಅರ್ಥಹೀನ ರೀತಿಯ ಹೊಂದಿದೆ.

907
00:49:20,000 --> 00:49:22,000
ನಾವು X ಅಥವಾ ವೈ ಅಥವಾ z ಎಂಬ ಇರಬಹುದು.

908
00:49:22,000 --> 00:49:25,000
ನಾವು, ಅದು ಅರ್ಥಕ್ಕೆ ಸ್ಥಿರ ಎಂದು ರಾಬ್ ಹೆಸರಿನ

909
00:49:25,000 --> 00:49:28,000
ಆದರೆ ನಿಜವಾಗಿಯೂ ಹೆಸರು, ಆ ಕ್ಷೇತ್ರದಲ್ಲಿ ಸ್ವತಃ ಒಳಗಿದೆ

910
00:49:28,000 --> 00:49:30,000
ಆದ್ದರಿಂದ ಈಗ ನಾನು ಈ ಹೊಂದಿರುತ್ತವೆ.

911
00:49:30,000 --> 00:49:33,000
ಇದು ತುಂಬಾ ನಾನು ಹಾರ್ಡ್ ಡೇವಿಡ್ ಕೋಡ್ ನೀವು ಅತ್ಯುತ್ತಮ ವಿನ್ಯಾಸ ಆಗಲೇ ಇಲ್ಲ.

912
00:49:33,000 --> 00:49:35,000
ನಾನು ಹಾರ್ಡ್ ರಾಬ್ ಕೋಡ್ ಮಾಡಿದ್ದೀರಿ.

913
00:49:35,000 --> 00:49:39,000
ಮತ್ತು ಇನ್ನೂ ಕೆಲವು ಪ್ರತಿಯನ್ನು ಅವಲಂಬಿಸಬೇಕಾಯಿತು ಮತ್ತು ನಾನು ಹೊಸ ಅಸ್ಥಿರ ಬಯಸುವ ಪ್ರತಿ ಬಾರಿ ಅಂಟಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

914
00:49:39,000 --> 00:49:43,000
ಮೇಲಾಗಿ, ನಾನು, ಸ್ಪಷ್ಟವಾಗಿ ಈ ಅಸ್ಥಿರ ಪ್ರತಿ ಒಂದು ಹೆಸರನ್ನು ನೀಡಲು ಹೊಂದಿವೆ

915
00:49:43,000 --> 00:49:46,000
ನಾನು ಹೆಚ್ಚು ಹೆಚ್ಚಾಗಿ ಈ ಅಸ್ಥಿರಗಳು ವಿವರಿಸಲು ಬಯಸುವ ಸಹ

916
00:49:46,000 --> 00:49:48,000
 ಹೆಚ್ಚು ಸಾರ್ವತ್ರಿಕವಾಗಿ ಮಾಹಿತಿ ವಿದ್ಯಾರ್ಥಿಗಳು.

917
00:49:48,000 --> 00:49:52,000
>> ಈಗ ನಾವು ಚೆನ್ನಾಗಿ ಕೆಲಸ ಎಂದು ಕಲ್ಪನೆಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಬಹುದು

918
00:49:52,000 --> 00:49:56,000
ಬದಲಿಗೆ, ನೀವು ಅಂತ ವೇರಿಯಬಲ್ ಕರೆಯಲ್ಪಡುವ ವಿದ್ಯಾರ್ಥಿಗಳು ನೀಡಲು ಏನು ತಿಳಿದಿದೆ ", ಸೇ

919
00:49:56,000 --> 00:50:01,000
ಮತ್ತು ಈಗ ನಾನು ಈ ಮತ್ತಷ್ಟು ಸಂಸ್ಕರಿಸಲು ಆದ್ದರಿಂದ ", ಇದನ್ನು ಗಾತ್ರದ 3 ಎಂದು ನಾವು,

920
00:50:01,000 --> 00:50:04,000
, ಕೈಯಾರೆ ಡಿಕ್ಲೇರ್ಡ್ ಡೇವಿಡ್ ತೊಡೆದುಹಾಕಲು

921
00:50:04,000 --> 00:50:08,000
ಮತ್ತು ನಾನು ಬದಲಿಗೆ [0] ಇಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ಮುಂತಾದ ಏನಾದರೂ ಹೇಳಬಹುದು.

922
00:50:08,000 --> 00:50:11,000
ನಾನು ನಂತರ, [0] ಇಲ್ಲಿ ವಿದ್ಯಾರ್ಥಿಗಳು ಹೇಳಬಹುದು

923
00:50:11,000 --> 00:50:14,000
ವಿದ್ಯಾರ್ಥಿಗಳು ಇಲ್ಲಿ, ಇತ್ಯಾದಿ [0], ಮತ್ತು ನಾನು ಸುತ್ತಲೂ ಹೋಗಬಹುದು

924
00:50:14,000 --> 00:50:16,000
ಮತ್ತು ರಾಬ್ ಆ ಸ್ವಚ್ಛಗೊಳಿಸಲು.

925
00:50:16,000 --> 00:50:19,000
ನಾನು ಈಗ ಬಹುಶಃ ಲೂಪ್ ಸೇರಿಸುವ ಬಗ್ಗೆ ಹೋಗಬಲ್ಲವರಾಗಿದ್ದರು

926
00:50:19,000 --> 00:50:23,000
ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಬಳಕೆದಾರರಿಂದ ಈ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯುವುದು GetString ಮತ್ತು GetInt ಬಳಸಿ.

927
00:50:23,000 --> 00:50:27,000
ಈ ಸಾಮಾನ್ಯವಾಗಿ ಕೆಟ್ಟ ಅಭ್ಯಾಸ ಏಕೆಂದರೆ ನಾನು ಸ್ಥಿರ ಸೇರಿಸುವ ಬಗ್ಗೆ ಹೋಗಬಲ್ಲವರಾಗಿದ್ದರು

928
00:50:27,000 --> 00:50:29,000
ಇಲ್ಲಿಯೇ 3 ರೀತಿಯಲ್ಲಿ ಹಾರ್ಡ್ ಕೋಡ್ ಕೆಲವು ನಿರಂಕುಶ ಸಂಖ್ಯೆ

929
00:50:29,000 --> 00:50:33,000
ಮತ್ತು ಆಗ ನೀವು ಯಾವುದೇ ಹೆಚ್ಚಿನ 3 ವಿದ್ಯಾರ್ಥಿಗಳು ತರಬೇಕಿರುವ ನೆನಪು.

930
00:50:33,000 --> 00:50:36,000
ಬಹುಶಃ ನನ್ನ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲು # ಬಳಸಲು ಉತ್ತಮ ಎಂದು

931
00:50:36,000 --> 00:50:40,000
ಮತ್ತು ಔಟ್, ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ, ನನ್ನನ್ನು ಮುಂದೆ ಹೋಗಿ ಈ ಸಾಮಾನ್ಯೀಕರಿಸುತ್ತದೆ ಮಾಡುವಂತಹ ಅಂಶವಾಗಿದೆ.

932
00:50:40,000 --> 00:50:43,000
>> ನನ್ನ ಇಂದಿನ ನಡುವೆ ಎಂದು ಉದಾಹರಣೆ ತೆರೆದುಕೊಳ್ಳಲು ಅವಕಾಶ

933
00:50:43,000 --> 00:50:46,000
ಮುಂಚಿತವಾಗಿ ಉದಾಹರಣೆಗಳು, structs1.

934
00:50:46,000 --> 00:50:49,000
ಈ # ಇಲ್ಲಿ ವ್ಯಾಖ್ಯಾನಿಸಲು ಬಳಸುವ ಸಂಪೂರ್ಣ ಕಾರ್ಯಕ್ರಮ

935
00:50:49,000 --> 00:50:51,000
ಮತ್ತು ನಾವು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ 3 ವಿದ್ಯಾರ್ಥಿಗಳು ಹೊಂದಿರುವ ನೀನು ಹೇಳುತ್ತಾರೆ.

936
00:50:51,000 --> 00:50:54,000
ಇಲ್ಲಿ ನಾನು, ವಿದ್ಯಾರ್ಥಿಗಳು ಒಂದು ವರ್ಗ ಮೌಲ್ಯದ ಘೋಷಿಸುವ ನಾನು

937
00:50:54,000 --> 00:50:57,000
ವಿದ್ಯಾರ್ಥಿಗಳು ಒಂದು ತರಗತಿಯ ಆದ್ದರಿಂದ, ಮತ್ತು ಈಗ ನಾನು ಒಂದು ಲೂಪ್ ಅನ್ನು ನಾನು

938
00:50:57,000 --> 00:51:00,000
ಕೇವಲ ಕೋಡ್ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸೊಗಸಾದ ಮಾಡಲು, ವರ್ಗ ಜನಪ್ರಿಯಗೊಳಿಸುವುದಕ್ಕೆ

939
00:51:00,000 --> 00:51:05,000
ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಅನ್ನು, ಹೀಗೆ 3 ಇದು ವಿದ್ಯಾರ್ಥಿಗಳು, ನಾನು = 0 ಬಂದ ಮೇಲೆ ತಿರುಗಿ.

940
00:51:05,000 --> 00:51:07,000
ನಂತರ ನಾನು ಈ ಆವೃತ್ತಿಯಲ್ಲಿ ಬಳಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್

941
00:51:07,000 --> 00:51:10,000
 ಯಾವ ವಿದ್ಯಾರ್ಥಿಯ ID ಯನ್ನು, ಮತ್ತು ನಾನು GetInt ಅದನ್ನು ಪಡೆಯಲು.

942
00:51:10,000 --> 00:51:13,000
ಯಾವ ವಿದ್ಯಾರ್ಥಿಯ ಹೆಸರು, ಮತ್ತು ನಂತರ ನಾನು GetString ನೊಂದಿಗೆ ಪಡೆಯಿರಿ.

943
00:51:13,000 --> 00:51:15,000
ವಿದ್ಯಾರ್ಥಿಯ ಮನೆ ಯಾವುದು? ನಾನು GetString ಅದನ್ನು ಪಡೆಯಲು.

944
00:51:15,000 --> 00:51:19,000
ತದನಂತರ ಇಲ್ಲಿ ಕೆಳಗೆ ನಾನು ಬದಲಾಯಿಸಲು ನಿರ್ಧರಿಸಿದರು

945
00:51:19,000 --> 00:51:22,000
ಈ ಔಟ್ ಮುದ್ರಿಸುವ ನಾನು ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಒಂದು ಲೂಪ್ ಅನ್ನು ಹೇಗೆ,

946
00:51:22,000 --> 00:51:24,000
ನಾನು ಯಾರು ಮುದ್ರಿಸುವ ನಾನು?

947
00:51:24,000 --> 00:51:27,000
ಕಾಮೆಂಟ್ ಪ್ರಕಾರ ನಾನು, ಮ್ಯಾಥರ್ ಯಾರಿಗಾದರೂ ಮುದ್ರಿಸುವ ನಾನು

948
00:51:27,000 --> 00:51:30,000
ಮತ್ತು ರಾಬ್ ಮತ್ತು ಟಾಮಿ ಆದ್ದರಿಂದ ಇತ್ಯಾದಿ-ವಾಸ್ತವವಾಗಿ ಟಾಮಿ ನ ಮ್ಯಾಥರ್ ಇದರ.

949
00:51:30,000 --> 00:51:34,000
ಟಾಮಿ ಮತ್ತು ಡೇವಿಡ್ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮುದ್ರಿತ ಎಂದು, ಆದರೆ ಹೇಗೆ ಈ ಕೆಲಸ?

950
00:51:34,000 --> 00:51:40,000
ನಾವು ಮೊದಲು ಈ ಕಾರ್ಯ ಕಾಣಬಹುದು, ಆದರೆ ಏನು ಎಂದು ಒಂದು ಊಹೆ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮಾಡಿಲ್ಲ.

951
00:51:40,000 --> 00:51:42,000
ತಂತಿಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ.

952
00:51:42,000 --> 00:51:45,000
>> ಇದು ತಿರುಗಿದರೆ ಏಕೆಂದರೆ ತಂತಿಗಳನ್ನು ಹೋಲಿಸುತ್ತದೆ ಹೇಗೆ ಸ್ವಲ್ಪ ಅಲ್ಲದ ಸ್ಪಷ್ಟವಾಗಿದೆ

953
00:51:45,000 --> 00:51:49,000
ಇದು ಅರ್ಥ 0 ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ತಂತಿಗಳು ಸಮ.

954
00:51:49,000 --> 00:51:53,000
ಇದನ್ನು -1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ಒಂದು, ಇತರ ಮೊದಲು ವರ್ಣಮಾಲೆಯ ಬರುತ್ತದೆ ಎಂದರೆ

955
00:51:53,000 --> 00:51:57,000
ಇದು ಇತರ ಪದದ ಅರ್ಥ +1 ಹಿಂದಿರುಗಿಸುತ್ತದೆ ವೇಳೆ ಮತ್ತು ವರ್ಣಮಾಲೆಯ ಬರುತ್ತದೆ

956
00:51:57,000 --> 00:52:00,000
ಇತರ ಮೊದಲು, ಮತ್ತು ನೀವು ಆನ್ಲೈನ್ ಅಥವಾ ಮ್ಯಾನ್ ಪುಟವನ್ನು ನೋಡಬಹುದು

957
00:52:00,000 --> 00:52:04,000
ನಿರ್ದಿಷ್ಟವಾದ ರೀತಿಯಲ್ಲಿ ಇದು ನೋಡಲು, ಆದರೆ ಈಗ ಮಾಡುತ್ತಿರುವ ಹೇಳುವ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ

958
00:52:04,000 --> 00:52:09,000
[ನಾನು]. ಮನೆ "ಮ್ಯಾಥರ್" ಸಮನಾದ ವೇಳೆ

959
00:52:09,000 --> 00:52:13,000
ನಂತರ ಮುಂದೆ ಹೋಗಿ ಆದ್ದರಿಂದ ಮುದ್ರಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಮ್ಯಾಥರ್ ರಲ್ಲಿ ಆಗಿದೆ.

960
00:52:13,000 --> 00:52:16,000
ಆದರೆ ಇಲ್ಲಿ ನಾವು ಮೊದಲು ನೋಡಿಲ್ಲ ವಿಷಯ, ಮತ್ತು ನಾವು ಈ ಹಿಂತಿರುಗಿ ಮಾಡುತ್ತೇವೆ.

961
00:52:16,000 --> 00:52:21,000
ನಾನು ನನ್ನ ಕಾರ್ಯಕ್ರಮಗಳು ಯಾವುದೇ ಇದನ್ನು ಹೊಂದುವ ಮರುಪಡೆಯಲು ಇಲ್ಲ.

962
00:52:21,000 --> 00:52:24,000
ಉಚಿತ ಸ್ಪಷ್ಟವಾಗಿ, ಮೆಮೊರಿ ಉಲ್ಲೇಖಿಸುವಾಗ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ಇದೆ

963
00:52:24,000 --> 00:52:31,000
ಆದರೆ ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಈ ಕಾರ್ಯಕ್ರಮದ ಕೆಳಭಾಗದಲ್ಲಿ ಈ ಲೂಪ್ ಯಾವ ಮೆಮೊರಿಯನ್ನು ಮುಕ್ತಗೊಳಿಸಿದ ನಾನು?

964
00:52:31,000 --> 00:52:34,000
ನಾನು ವ್ಯಕ್ತಿಯ ಹೆಸರು ಮುಕ್ತಗೊಳಿಸಿದ ನಾನು ತೋರುತ್ತಿದೆ

965
00:52:34,000 --> 00:52:37,000
ಮತ್ತು ವ್ಯಕ್ತಿಯ ಮನೆ, ಆದರೆ ಯಾಕೆ ಎಂದು?

966
00:52:37,000 --> 00:52:41,000
>> ನೀವು GetString ಬಳಸಿಕೊಂಡು ನಾವು ಎಲ್ಲಾ ಈ ವಾರಗಳ ತಿರುಗಿದರೆ

967
00:52:41,000 --> 00:52:45,000
ನಾವು ರೀತಿಯ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಪ್ರತಿಯೊಂದು ಒಂದು ದೋಷವನ್ನು ಪರಿಚಯಿಸುವ ಮಾಡಲಾಗಿದೆ.

968
00:52:45,000 --> 00:52:51,000
ನೀವು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಮರಳಬಹುದು ಎಷ್ಟು ವಿನ್ಯಾಸ ಗೊತ್ತುಪಡಿಸುತ್ತದೆ ನೆನಪಿನಿಂದ GetString,

969
00:52:51,000 --> 00:52:55,000
ಹಾಗೆ ಡೇವಿಡ್, ಅಥವಾ ರಾಬ್, ಮತ್ತು ನಂತರ ನೀವು ಬಯಸುವ ಯಾವುದೇ ಮಾಡಬಹುದು

970
00:52:55,000 --> 00:52:59,000
ನಾವು ನಿಮಗೆ ಮೆಮೊರಿ ಕಾಯ್ದಿರಿಸಲಾಗಿದೆ ನೀವು ಏಕೆಂದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆ ದಾರದಿಂದ.

971
00:52:59,000 --> 00:53:02,000
ಸಮಸ್ಯೆಯನ್ನು ನೀವು GetString ಕರೆ ಪ್ರತಿ ಬಾರಿ ಈ ಸಮಯ

972
00:53:02,000 --> 00:53:05,000
ನಾವು, GetString ಲೇಖಕರು, ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಕೇಳುವ ಮಾಡಲಾಗಿದೆ

973
00:53:05,000 --> 00:53:07,000
ಈ ತಂತಿಗೆ ನಮಗೆ ರಾಮ್ ಬಿಟ್ ನೀಡಿ.

974
00:53:07,000 --> 00:53:09,000
ಈ ಮುಂದಿನ ತಂತಿಗೆ ನಮಗೆ ರಾಮ್ ಬಿಟ್ ನೀಡಿ.

975
00:53:09,000 --> 00:53:11,000
ಈ ಮುಂದಿನ ಸ್ಟ್ರಿಂಗ್ ಕೆಲವು ಹೆಚ್ಚು RAM ನೀಡಿ.

976
00:53:11,000 --> 00:53:13,000
ಏನು, ಪ್ರೋಗ್ರಾಮರ್, ಏನು ಇಲ್ಲ

977
00:53:13,000 --> 00:53:15,000
, ಆ ಮೆಮೊರಿ ಮರಳಿ ನೀಡುವ ಇದೆ

978
00:53:15,000 --> 00:53:17,000
ಆದ್ದರಿಂದ ಈ ಹಲವಾರು ವಾರಗಳವರೆಗೆ ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ನೀವು ಬರೆದ ನೀವು

979
00:53:17,000 --> 00:53:20,000
ಅವರು ಬಳಸುವುದನ್ನು ಮುಂದುವರಿಸಬಹುದು ಬಗೆಗಿನ ಮೆಮೊರಿ ಅಧಿಕ ಎಂದು ಏನನ್ನು ಹೊಂದಿದ್ದವು

980
00:53:20,000 --> 00:53:24,000
ಹೆಚ್ಚು ಹೆಚ್ಚು ಮೆಮೊರಿ ನೀವು GetString ಕರೆ, ಮತ್ತು ಫೈನ್ ಪ್ರತಿಯೊಂದು ಸಮಯ.

981
00:53:24,000 --> 00:53:27,000
ಆ ಆಸಕ್ತಿಕರ ಏಕೆಂದರೆ ನಾವು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಮೊದಲ ವಾರಗಳಲ್ಲಿ ಹಾಗೆ

982
00:53:27,000 --> 00:53:29,000
ಸ್ಟ್ರಿಂಗ್ ಬರುವ ಅಲ್ಲಿ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಕಾಗಿಲ್ಲ ಗೆ.

983
00:53:29,000 --> 00:53:34,000
ನೀವು ಬಯಸುವ ಎಲ್ಲಾ ಪದ ಬಳಕೆದಾರ ರೀತಿಯ ಇದು ಸೈನ್ ಹಿಂತಿರುಗಬೇಕಾಗಿದೆ ರಾಬ್ ಆಗಿದೆ

984
00:53:34,000 --> 00:53:38,000
>> ಆದರೆ ಮುಂದೆ ಸಾಗುವ ನಾವು ಈಗ ಈ ಬಗ್ಗೆ ಹೆಚ್ಚು ಅತ್ಯಾಧುನಿಕ ಪಡೆಯುವಲ್ಲಿ ಪ್ರಾರಂಭಿಸಬೇಕು.

985
00:53:38,000 --> 00:53:42,000
ನಾವು ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ನಾವು ಉತ್ತಮ ಅಂತಿಮವಾಗಿ ಬ್ಯಾಕ್ ಹ್ಯಾಂಡ್.

986
00:53:42,000 --> 00:53:45,000
ಇಲ್ಲವಾದರೆ ನಿಮ್ಮ ಮ್ಯಾಕ್ ಅಥವಾ ಪಿಸಿ ಮೇಲೆ ವಾಸ್ತವ ಜಗತ್ತಿನಲ್ಲಿ ನೀವು ಕೆಲವೊಮ್ಮೆ ಅನುಭವಿ ಹೊಂದಿರಬಹುದು

987
00:53:45,000 --> 00:53:50,000
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅಂತಿಮವಾಗಿ ಸ್ಥಗಿತಗೊಂಡಿತು ರುಬ್ಬುವ ಅಲ್ಲಿ ಲಕ್ಷಣಗಳು

988
00:53:50,000 --> 00:53:54,000
ಅಥವಾ ಸ್ಟುಪಿಡ್ ತಿರುಗುವ ಬೀಚ್ ಚೆಂಡನ್ನು ಕೇವಲ ಗಣಕದ ವಶಪಡಿಸಿಕೊಂಡಿದ್ದ ಇದೆ

989
00:53:54,000 --> 00:53:56,000
ಸಂಪೂರ್ಣ ಗಮನ ಮತ್ತು ನೀವು ಕೆಲಸಗಳನ್ನು ಸಾಧ್ಯವಿಲ್ಲ.

990
00:53:56,000 --> 00:54:00,000
ಆ ದೋಷಗಳನ್ನು ಯಾವುದೇ ಸಂಖ್ಯೆಯ ವಿವರಿಸಬಹುದು, ಆದರೆ ಆ ಸಂಭವನೀಯ ದೋಷಗಳನ್ನು ನಡುವೆ ಮಾಡಬಹುದು

991
00:54:00,000 --> 00:54:03,000
ವಿಷಯಗಳನ್ನು ಮೆಮೊರಿ ಸೋರುವಿಕೆ ಎಂದು ಹಕ್ಕಿಯು ತಂತ್ರಾಂಶ ಆ ತುಂಡು ಬರೆದ ಯಾರಾದರೂ

992
00:54:03,000 --> 00:54:07,000
ನೀವು ಉಚಿತ ಮೆಮೊರಿ ಮರೆಯದಿರಿ ಮಾಡಲಿಲ್ಲ ಬಳಸುತ್ತಿದ್ದೀರಿ

993
00:54:07,000 --> 00:54:10,000
ಅವನು ಅಥವಾ ಅವಳು, ಕಾರ್ಯಾಚರಣೆ ವ್ಯವಸ್ಥೆಯ ಕೇಳಿದಾಗ ಆ

994
00:54:10,000 --> 00:54:14,000
ಒಂದು CS50 ವಿಷಯ ಏಕೆಂದರೆ, GetString ಬಳಸಿಕೊಂಡು, ಆದರೆ ಇದೇ ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುವ

995
00:54:14,000 --> 00:54:16,000
ಮೆಮೊರಿಗೆ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕೇಳುತ್ತಾರೆ.

996
00:54:16,000 --> 00:54:19,000
ನೀವು ಅಥವಾ ಅವರು ಸ್ಕ್ರೂ ಮತ್ತು ವೇಳೆ ನಿಜವಾಗಿ ಆ ಮೆಮೊರಿ ಮರಳುವುದಿಲ್ಲ

997
00:54:19,000 --> 00:54:24,000
ಒಂದು ಪ್ರೋಗ್ರಾಂ ನಿಧಾನಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ನಿಧಾನಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕೆಳಗೆ ನಿಧಾನಗೊಳಿಸುತ್ತದೆ ಎಂದು ಎಂದು ಲಕ್ಷಣಗಳೂ

998
00:54:24,000 --> 00:54:26,000
ನೀವು ಉಚಿತ ಕರೆ ಮರೆಯದಿರಿ ಹೊರತು.

999
00:54:26,000 --> 00:54:28,000
>> ಯಾವಾಗ ಮತ್ತು ಏಕೆ ನೀವು ಉಚಿತ ಕರೆ ಎಂದು ನಾವು ಹಿಂತಿರುಗಿ ವಿಲ್

1000
00:54:28,000 --> 00:54:32,000
ಆದರೆ ಕೇವಲ ಒಳಿತನ್ನು ತರುವುದಕ್ಕಾಗಿ ಮುಂದೆ ಹೋಗಿ ಈ ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಪ್ರಯತ್ನಿಸೋಣ.

1001
00:54:32,000 --> 00:54:35,000
ಈ structs1 ಕರೆಯಲಾಯಿತು, ನಮೂದಿಸಿ.

1002
00:54:35,000 --> 00:54:40,000
ಡೇವಿಡ್ ಮ್ಯಾಥರ್, ನನಗೆ ಮುಂದುವರಿಯಲು ಮತ್ತು structs1 ರನ್ 123 ಅವಕಾಶ

1003
00:54:40,000 --> 00:54:47,000
456, ರಾಬ್ ಕಿರ್ಕ್ಲ್ಯಾಂಡ್, 789,

1004
00:54:47,000 --> 00:54:50,000
ಟಾಮಿ ಮ್ಯಾಥರ್ ಮತ್ತು ನಾವು ಮ್ಯಾಥರ್ ಡೇವಿಡ್ ನ ನೋಡಿ, ಟಾಮಿ ನ ಮ್ಯಾಥರ್ ರಲ್ಲಿ.

1005
00:54:50,000 --> 00:54:53,000
ಈ ಪ್ರೋಗ್ರಾಂ ಕೆಲಸ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಕೇವಲ ಸ್ವಲ್ಪ ವಿವೇಕ ಚೆಕ್ ಹೊಂದಿದೆ.

1006
00:54:53,000 --> 00:54:56,000
ಈಗ, ದುರದೃಷ್ಟವಶಾತ್, ಈ ಪ್ರೋಗ್ರಾಂ ಆ ಸ್ವಲ್ಪ ಕಿರಿಕಿರಿಯನ್ನುಂಟು ಆಗಿದೆ

1007
00:54:56,000 --> 00:55:00,000
ನಾನು 9 ವಿವಿಧ ತಂತಿ ಎಲ್ಲಾ ಕೆಲಸ ಟೈಪಿಸಿದ ಮಾಡಲಿಲ್ಲ, enter ಅನ್ನು ಒತ್ತಿ

1008
00:55:00,000 --> 00:55:04,000
ಮ್ಯಾಥರ್ ರಲ್ಲಿ ಯಾರು ಹೇಳಿದರು, ಇನ್ನೂ ಸ್ಪಷ್ಟವಾಗಿ ನಾನು ಟೈಪಿಸಿದ ಏಕೆಂದರೆ ಈಗಾಗಲೇ ಮ್ಯಾಥರ್ ರಲ್ಲಿ ಯಾರು ತಿಳಿದಿದ್ದರು ಮಾಡಲಾಯಿತು.

1009
00:55:04,000 --> 00:55:07,000
ಈ ಕಾರ್ಯಕ್ರಮ ಹೆಚ್ಚು ಒಂದು ಡೇಟಾಬೇಸ್ ಮಾದರಿಯ ವೇಳೆ ಇದು ಕನಿಷ್ಠ ಸಂತೋಷವನ್ನು ಎಂದು

1010
00:55:07,000 --> 00:55:10,000
ಮತ್ತು ನಿಜವಾಗಿ ನಾನು ಬೆರಳಚ್ಚಿಸಿದ ಯಾವ ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ

1011
00:55:10,000 --> 00:55:12,000
ಆದ್ದರಿಂದ ನಾನು ಮತ್ತೆ ಇನ್ಪುಟ್ ಈ ವಿದ್ಯಾರ್ಥಿ ದಾಖಲೆಗಳು ಯಾವತ್ತೂ.

1012
00:55:12,000 --> 00:55:15,000
ಬಹುಶಃ ಇದು registrarial ವ್ಯವಸ್ಥೆಯ ರೀತಿಯಲ್ಲಿ.

1013
00:55:15,000 --> 00:55:21,000
>> ನಾವು, ಕಡತ I / O, ಕಡತ ಇನ್ಪುಟ್ ಮತ್ತು ಔಟ್ಪುಟ್ ಎಂದು ಈ ತಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಹೀಗೆ ಮಾಡಬಹುದು

1014
00:55:21,000 --> 00:55:24,000
ನೀವು ಕಡತಗಳನ್ನು ಓದಲು ಅಥವಾ ಕಡತಗಳನ್ನು ಬರೆಯಲು ಬೇಕಾದ ಸಮಯ ಹೇಳುವ ಒಂದು ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ

1015
00:55:24,000 --> 00:55:26,000
ನೀವು ಕಾರ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟ ಈ ಮಾಡಬಹುದು.

1016
00:55:26,000 --> 00:55:29,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಉದಾಹರಣೆಗೆ structs2.c ತೆರೆಯಲು ಅವಕಾಶ

1017
00:55:29,000 --> 00:55:33,000
ಇದು ಹೆಚ್ಚುಕಡಿಮೆ ಒಂದೇ ಆಗಿದೆ, ಆದರೆ ಇದು ಈಗ ಏನು ನೋಡೋಣ ನ.

1018
00:55:33,000 --> 00:55:36,000
ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಾನು ವಿದ್ಯಾರ್ಥಿಗಳು ಒಂದು ವರ್ಗ ಘೋಷಿಸಿದ.

1019
00:55:36,000 --> 00:55:38,000
ನಾನು ನಂತರ, ಬಳಕೆದಾರರ ಇನ್ಪುಟ್ ಜೊತೆಗೆ ವರ್ಗ ಜನಪ್ರಿಯಗೊಳಿಸುವುದಕ್ಕೆ

1020
00:55:38,000 --> 00:55:41,000
ಆದ್ದರಿಂದ ಕೋಡ್ ಆ ಸಾಲುಗಳನ್ನು ನಿಖರವಾಗಿ ಮೊದಲು ಇದ್ದಾರೆ.

1021
00:55:41,000 --> 00:55:45,000
ಮ್ಯಾಥರ್ ನಲ್ಲಿ ಎಲ್ಲರೂ ನಿರಂಕುಶವಾಗಿ ಮೊದಲು ನಾನು ಇಲ್ಲಿ ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ವೇಳೆ ನಂತರ ನಾನು ಮುದ್ರಿಸಲು,

1022
00:55:45,000 --> 00:55:47,000
ಆದರೆ ಈ ಒಂದು ಆಸಕ್ತಿದಾಯಕ ಹೊಸ ಲಕ್ಷಣವಾಗಿದೆ.

1023
00:55:47,000 --> 00:55:51,000
, ಕೋಡ್ ಈ ಸಾಲುಗಳು ಹೊಸ, ಮತ್ತು ಅವರು ಇಲ್ಲಿ ಏನನ್ನಾದರೂ ಪರಿಚಯಿಸಲು

1024
00:55:51,000 --> 00:55:55,000
ಫೈಲ್ ಎಲ್ಲಾ ಕ್ಯಾಪ್ಸ್, ಜೊತೆಗೆ ಇಲ್ಲಿ * ಹೊಂದಿದೆ.

1025
00:55:55,000 --> 00:55:58,000
ನನ್ನ ಜೊತೆಗೆ ಇಲ್ಲಿ ಮೇಲೆ, ಇಲ್ಲಿ ಮೇಲೆ * ಈ ಚಲಿಸೋಣ.

1026
00:55:58,000 --> 00:56:00,000
>> ಈ ಕಾರ್ಯವನ್ನು ನಾವು ಮೊದಲು ನೋಡಿಯೇ ಇಲ್ಲ, fopen,

1027
00:56:00,000 --> 00:56:03,000
ಆದರೆ ತೆರೆದ ಕಡತ ಅರ್ಥ, ಆದ್ದರಿಂದ ಈ ಮೂಲಕ ಅವರ ಕೆನೆರಹಿತ ಅವಕಾಶ

1028
00:56:03,000 --> 00:56:05,000
ಮತ್ತು ಇದು ನಾವು ಭವಿಷ್ಯದ psets ರಲ್ಲಿ ಹಿಂತಿರುಗಿ ನಾವು ವಿಷಯ

1029
00:56:05,000 --> 00:56:10,000
ಆದರೆ ಇಲ್ಲಿ ಈ ಸಾಲಿನ ಮೂಲಭೂತವಾಗಿ, ಡೇಟಾಬೇಸ್ ಎಂಬ ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ

1030
00:56:10,000 --> 00:56:13,000
ಇದು ನಿರ್ದಿಷ್ಟವಾಗಿ ಅದು ಏನು ಎಂಬುದನ್ನು ರೀತಿಯಲ್ಲಿ ಅದು ತೆರೆಯುತ್ತದೆ?

1031
00:56:13,000 --> 00:56:15,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

1032
00:56:15,000 --> 00:56:19,000
ಬಲ, ಆದ್ದರಿಂದ "W" ಕೇವಲ ಅದು ಕಾರ್ಯ ವ್ಯವಸ್ಥೆಯನ್ನು ಹೇಳುವ ನ ಅರ್ಥ

1033
00:56:19,000 --> 00:56:21,000
ನಾನು ಅದನ್ನು ಬರೆಯಬಹುದು ರೀತಿಯಲ್ಲಿ ಈ ಕಡತವನ್ನು ತೆರೆಯಲು.

1034
00:56:21,000 --> 00:56:23,000
ನಾನು ಅದನ್ನು ಓದಿ ಬಯಸುವುದಿಲ್ಲ. ನಾನು ಅದನ್ನು ನೋಡಲು ಬಯಸುವುದಿಲ್ಲ.

1035
00:56:23,000 --> 00:56:26,000
ನಾನು, ಬದಲಾಯಿಸಲು ಮತ್ತು ಅದನ್ನು ಸಮರ್ಥವಾಗಿ ವಿಷಯವನ್ನು ಸೇರಿಸಲು ಬಯಸುವ

1036
00:56:26,000 --> 00:56:28,000
ಮತ್ತು ಫೈಲ್ ಡೇಟಾಬೇಸ್ ಎಂದು ಹೋಗುತ್ತದೆ.

1037
00:56:28,000 --> 00:56:30,000
ಇದು ಏನು ಎಂದು ಕರೆಯಬಹುದು.

1038
00:56:30,000 --> 00:56:32,000
ಈ database.txt ಆಗಿರಬಹುದು. ಈ. ಡಿಬಿ ಆಗಿರಬಹುದು.

1039
00:56:32,000 --> 00:56:37,000
ಈ foo ನಂತಹ ಪದ ಆಗಿರಬಹುದು, ಆದರೆ ನಾನು ನಿರಂಕುಶವಾಗಿ ಕಡತ ಡೇಟಾಬೇಸ್ ಹೆಸರು ಆಯ್ಕೆ.

1040
00:56:37,000 --> 00:56:42,000
ನಾವು ಸಮಯ ಉತ್ತಮ ವಿವರ ಹಿಂತಿರುಗಬೇಕಾಗಿದೆ ಮಾಡುತ್ತೇವೆ ಎಂದು ಸ್ವಲ್ಪ ವಿವೇಕ ಚೆಕ್ ಆಗಿದೆ

1041
00:56:42,000 --> 00:56:47,000
FP, ಕಡತ ಪಾಯಿಂಟರ್ ಫಾರ್, ಸಮಾನ ಸಾಂಕೇತಿಕಕೊಂಡಿಯು ಇದ್ದಲ್ಲಿ ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಅರ್ಥ.

1042
00:56:47,000 --> 00:56:51,000
>> ಉದ್ದ ಕಥೆ ಸಣ್ಣ, fopen ರೀತಿಯ ಕಾರ್ಯಗಳನ್ನು ಕೆಲವೊಮ್ಮೆ ವಿಫಲವಾಗುತ್ತದೆ.

1043
00:56:51,000 --> 00:56:53,000
ಬಹುಶಃ ಕಡತ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಬಹುಶಃ ನೀವು ಡಿಸ್ಕ್ ಸ್ಥಳಾವಕಾಶವಿಲ್ಲ.

1044
00:56:53,000 --> 00:56:55,000
ಬಹುಶಃ ನೀವು ಆ ಫೋಲ್ಡರ್ಗೆ ಅನುಮತಿಯಿಲ್ಲ

1045
00:56:55,000 --> 00:56:58,000
fopen ಶೂನ್ಯ ಏನೋ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಹಾಗಾಗಿ ಸಮಸ್ಯೆ ಕಂಡುಬಂದಿದೆ.

1046
00:56:58,000 --> 00:57:02,000
Fopen ಶೂನ್ಯ ಹಿಂದಿರುಗಲು ಇದ್ದಲ್ಲಿ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ಎಲ್ಲಾ ಬಾವಿ

1047
00:57:02,000 --> 00:57:04,000
ಮತ್ತು ನಾನು ಈ ಕಡತಕ್ಕೆ ಬರೆಯಲು ಆರಂಭಿಸಬಹುದು.

1048
00:57:04,000 --> 00:57:06,000
ಇಲ್ಲಿ ಹೊಸ ಟ್ರಿಕ್ಸ್.

1049
00:57:06,000 --> 00:57:08,000
ಈ ನನ್ನ ವಿದ್ಯಾರ್ಥಿಗಳು ಪ್ರತಿ ಮೇಲೆ iterating ಎಂದು ಒಂದು ಫಾರ್ ಲೂಪ್

1050
00:57:08,000 --> 00:57:10,000
ಮತ್ತು ಈ, ನಾವು ಮೊದಲು ಮಾಡಿದ ಎಂಬುದನ್ನು ಆದ್ದರಿಂದ ಹೋಲುತ್ತದೆ

1051
00:57:10,000 --> 00:57:15,000
ಆದರೆ ಈ ಕಾರ್ಯ, printf printf ಕಡತ fprintf ಎಂಬ ಅವರ ಸಂಬಂಧಿಯಾಗಿದ್ದಾರೆ

1052
00:57:15,000 --> 00:57:18,000
ಮತ್ತು ಇದು ಕೇವಲ 2 ರೀತಿಯಲ್ಲಿ ವಿಭಿನ್ನ ಗಮನಿಸುವುದಿಲ್ಲ.

1053
00:57:18,000 --> 00:57:20,000
ಒಂದು, ಇದು, ಬದಲಿಗೆ ಪುಟ F ಆರಂಭವಾಗುತ್ತದೆ

1054
00:57:20,000 --> 00:57:23,000
ಆದರೆ ನಂತರ ತನ್ನ ಮೊದಲ ವಾದವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಏನು?

1055
00:57:23,000 --> 00:57:25,000
[ವಿದ್ಯಾರ್ಥಿಗಳು] ಕಡತ. >> ಇದು ಒಂದು ಕಡತದ.

1056
00:57:25,000 --> 00:57:30,000
ನಾವು ಅಂತಿಮವಾಗಿ ಕಡತ ಪಾಯಿಂಟರ್ ಏನು ಹೊರತುಪಡಿಸಿ ಕೀಟಲೆ ವಿಲ್ ಇದು FP ಎಂದು ಈ ವಸ್ತು,

1057
00:57:30,000 --> 00:57:35,000
ಆದರೆ ಈಗ FP ಸರಳವಾಗಿ, ನಾನು ತೆರೆದಿದ್ದೀರಿ ಫೈಲ್ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

1058
00:57:35,000 --> 00:57:41,000
ಆದ್ದರಿಂದ fprintf ಇಲ್ಲಿ, ಕಡತ ಈ ಬಳಕೆದಾರನ ID ಯನ್ನು ಮುದ್ರಿಸಲಾಗುವುದಿಲ್ಲ ತೆರೆಗೆ ಹೇಳುತ್ತಾರೆ.

1059
00:57:41,000 --> 00:57:44,000
ಕಡತವನ್ನು ಬಳಕೆದಾರನ ಹೆಸರು ಅಲ್ಲದ ತೆರೆಗೆ, ಮುದ್ರಿಸು

1060
00:57:44,000 --> 00:57:47,000
ಕಡತದ ಅಲ್ಲ, ನಿಸ್ಸಂಶಯವಾಗಿ, ಕೆಳಗೆ ಇಲ್ಲಿ ನಂತರ ತೆರೆಗೆ, ಮತ್ತು ಮನೆ

1061
00:57:47,000 --> 00:57:50,000
ಕಡತ ಮುಚ್ಚಿ, ನಂತರ ಕೆಳಗೆ ಇಲ್ಲಿ ಮೆಮೊರಿ ಮುಕ್ತ.

1062
00:57:50,000 --> 00:57:53,000
>> ಈ ಆವೃತ್ತಿ 2 ಮತ್ತು ಆವೃತ್ತಿ 1 ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದರೆ

1063
00:57:53,000 --> 00:57:58,000
fopen ಪರಿಚಯ ಮತ್ತು * ಈ ಫೈಲ್

1064
00:57:58,000 --> 00:58:01,000
ಮತ್ತು fprintf ಈ ಕಲ್ಪನೆಯು, ಆದ್ದರಿಂದ ಇದರ ಅಂತಿಮ ಪರಿಣಾಮ ಏನು ನೋಡೋಣ.

1065
00:58:01,000 --> 00:58:03,000
ನನ್ನ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ಹೋಗಲು ಅವಕಾಶ.

1066
00:58:03,000 --> 00:58:06,000
ನಮೂದಿಸಿ, ನನ್ನ structs2 ಔಟ್ ಲೆಟ್.

1067
00:58:06,000 --> 00:58:09,000
ಎಲ್ಲಾ ಚೆನ್ನಾಗಿ ಹೊಂದಿದೆ ತೋರುತ್ತಿದೆ. ನ structs2 ಮರುಪ್ರದರ್ಶನ ಲೆಟ್.

1068
00:58:09,000 --> 00:58:15,000
123, ಡೇವಿಡ್ ಮ್ಯಾಥರ್, 456, ರಾಬ್ ಕಿರ್ಕ್ಲ್ಯಾಂಡ್,

1069
00:58:15,000 --> 00:58:19,000
789, ಟಾಮಿ ಮ್ಯಾಥರ್ ನಮೂದಿಸಿ.

1070
00:58:19,000 --> 00:58:23,000
ಅದೇ ವರ್ತಿಸಿದರು ಕಾಣುತ್ತದೆ, ಆದರೆ ನಾನು ಈಗ LS ಹೋದರೆ

1071
00:58:23,000 --> 00:58:28,000
ನನ್ನ ಕೋಡ್ ನಡುವೆ ಇಲ್ಲಿ ಯಾವ ಫೈಲ್ ಗಮನಿಸಿ, ಡೇಟಾಬೇಸ್,

1072
00:58:28,000 --> 00:58:32,000
ಇದರಿಂದ ಆ ಆ, ದತ್ತಸಂಚಯದ ಜಿಎಡಿಟ್ Name ಮತ್ತು ನೋಟ ತೆರೆಯಲು ಅವಕಾಶ.

1073
00:58:32,000 --> 00:58:34,000
ಇದು ಫೈಲ್ ಫಾರ್ಮ್ಯಾಟ್ಗಳು ಸೆಕ್ಸಿಯೆಸ್ಟ್ ಅಲ್ಲ.

1074
00:58:34,000 --> 00:58:38,000
ಇದು ನಿಜವಾಗಿಯೂ ಸಾಲಿಗೆ ಸಾಲಿಗೆ ಅಕ್ಷಾಂಶ ರೇಖೆಯ ಒಂದು ತುಣುಕು

1075
00:58:38,000 --> 00:58:42,000
ಆದರೆ ಎಕ್ಸೆಲ್ ಅಥವಾ CSV ಫೈಲ್ಗಳನ್ನು ಬಳಸುವ ನೀವು ಆ, ಅಲ್ಪವಿರಾಮ, ಮೌಲ್ಯಗಳು ಪ್ರತ್ಯೇಕಿಸಿ

1076
00:58:42,000 --> 00:58:47,000
ನಾನು ಖಂಡಿತವಾಗಿಯೂ ಬದಲಿಗೆ ಬಹುಶಃ ಈ ರೀತಿಯ ಮಾಡಲು fprintf ಬಳಸಲಾಗುತ್ತದೆ ಸಾಧ್ಯವಿಲ್ಲ

1077
00:58:47,000 --> 00:58:50,000
ನಾನು ವಾಸ್ತವವಾಗಿ ಒಂದು ಎಕ್ಸೆಲ್ ಕಡತವನ್ನು ಸಮಾನ ರಚಿಸಲು ಹೀಗಾಗಿ

1078
00:58:50,000 --> 00:58:53,000
ಅಲ್ಪವಿರಾಮಗಳಿಂದ, ಕೇವಲ ಹೊಸ ಸಾಲುಗಳನ್ನು ವಿಷಯಗಳನ್ನು ಪ್ರತ್ಯೇಕತೆ.

1079
00:58:53,000 --> 00:58:56,000
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾನು ಬದಲಿಗೆ ಅಲ್ಪವಿರಾಮಗಳಿಂದ ಬದಲಿಗೆ ಹೊಸ ಸಾಲುಗಳನ್ನು ಬಳಸಿದ ವೇಳೆ

1080
00:58:56,000 --> 00:59:01,000
ನಾನು ಬದಲಿಗೆ ಈ ರೀತಿ ಮಾಡಿದ ನಾನು ಅಕ್ಷರಶಃ ಎಕ್ಸೆಲ್ ಈ ಡೇಟಾಬೇಸ್ ಫೈಲ್ ತೆರೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

1081
00:59:01,000 --> 00:59:03,000
ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳಬೇಕೆಂದರೆ, ಈಗ ನಾವು ಕಡತಗಳನ್ನು ಬರೆಯಲು ಅಧಿಕಾರ ಹೊಂದಿರುವ

1082
00:59:03,000 --> 00:59:07,000
ನಾವು ಈಗ ಡಿಸ್ಕ್ ಸುತ್ತ ಕೀಪಿಂಗ್, ಮುಂದುವರಿದ ಅಕ್ಷಾಂಶ ಆರಂಭಿಸಬಹುದು

1083
00:59:07,000 --> 00:59:10,000
ನಾವು ಮತ್ತೆ ಮತ್ತೆ ಸುಮಾರು ಮಾಹಿತಿಯನ್ನು ಇರಿಸಬಹುದು ಆದ್ದರಿಂದ.

1084
00:59:10,000 --> 00:59:14,000
ಈಗ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಪರಿಚಿತ ಇತರ ವಸ್ತುಗಳ ಒಂದೆರಡು ಗಮನಿಸಿ.

1085
00:59:14,000 --> 00:59:16,000
ಈ ಸಿ ಕಡತದ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಾವು typedef ಹೊಂದಿವೆ

1086
00:59:16,000 --> 00:59:21,000
ನಾವು ಒಂದು ಪದ ಪ್ರತಿನಿಧಿಸುವ ಒಂದು ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೇನೆ, ಏಕೆಂದರೆ

1087
00:59:21,000 --> 00:59:25,000
ಈ ರೀತಿಯ ಪದ ಕರೆಯಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ, ಮತ್ತು ಒಳಗೆ ಈ ರಚನೆಯ

1088
00:59:25,000 --> 00:59:27,000
ಈಗ ಸ್ವಲ್ಪ ರಸಿಕ ಇಲ್ಲಿದೆ.

1089
00:59:27,000 --> 00:59:30,000
ಏಕೆ ಪದ ಸ್ಪಷ್ಟವಾಗಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾಡಲ್ಪಟ್ಟಿದೆ?

1090
00:59:30,000 --> 00:59:33,000
ಕೇವಲ ಅಂತರ್ಬೋಧೆಯಿಂದ ಪದ ಏನು?

1091
00:59:33,000 --> 00:59:35,000
>> ಇದು ಅಕ್ಷರಗಳ ಸರಣಿ ದ.

1092
00:59:35,000 --> 00:59:37,000
ಇದು ಒಂದರ ಹಿಂದೆ ಒಂದರಂತೆ ಮತ್ತೆ ಅಕ್ಷರಗಳನ್ನು ಅನುಕ್ರಮ ಇಲ್ಲಿದೆ.

1093
00:59:37,000 --> 00:59:41,000
ಎಲ್ಲಾ ಕ್ಯಾಪ್ಸ್ ಅಕ್ಷರಗಳನ್ನು ನಾವು ನಿರಂಕುಶವಾಗಿ ಹೇಳುತ್ತಾರೆ ಎಂದು ಸಂಭವಿಸುತ್ತದೆ ಗರಿಷ್ಠ ಉದ್ದ

1094
00:59:41,000 --> 00:59:44,000
ನಾವು ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಫಾರ್ ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು ನಿಘಂಟಿನಲ್ಲಿ ಯಾವುದೇ ಪದದ.

1095
00:59:44,000 --> 00:59:46,000
ನಾನು ಒಂದು +1 ಹೊಂದಿಲ್ಲ?

1096
00:59:46,000 --> 00:59:48,000
ಶೂನ್ಯ ಪಾತ್ರ.

1097
00:59:48,000 --> 00:59:51,000
ನಾವು Bananagrams ಉದಾಹರಣೆಗೆ ಮಾಡಿದಾಗ ನಾವು ವಿಶೇಷ ಮೌಲ್ಯದ ಅಗತ್ಯವಿದೆ ಮರುಪಡೆಯಲು

1098
00:59:51,000 --> 00:59:55,000
ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಪದದ ಕೊನೆಯಲ್ಲಿ ಕ್ರಮದಲ್ಲಿ

1099
00:59:55,000 --> 00:59:59,000
ಸಮಸ್ಯೆ ಸೆಟ್ ವಿವರಣೆಯನ್ನು ಹೇಳುತ್ತಾರೆ ಪದಗಳನ್ನು ವಾಸ್ತವವಾಗಿ ಕೊನೆಗೊಂಡಿದೆ ಅಲ್ಲಿ ನ, ಮತ್ತು ಮಾಹಿತಿ

1100
00:59:59,000 --> 01:00:03,000
ಇಲ್ಲಿ ನಾವು, ಒಂದು ನಿರ್ದಿಷ್ಟ ಪದ ಒಂದು ಬೂಲಿಯನ್ ಮೌಲ್ಯವನ್ನು ಸಂಯೋಜಿಸುವಾಗ ನೀವು

1101
01:00:03,000 --> 01:00:05,000
ಒಂದು ಧ್ವಜ, ಆದ್ದರಿಂದ, ಸರಿ ಅಥವಾ ತಪ್ಪು ಮಾತನಾಡಲು.

1102
01:00:05,000 --> 01:00:09,000
ನಾವು ಅರ್ಥ ಏಕೆಂದರೆ ನೀವು ಈಗಾಗಲೇ ಈ ಪದ ಕಂಡು

1103
01:00:09,000 --> 01:00:13,000
ನಾವು ವಿಚಾರಿಸಿದಾಗ ಒಂದು ದಾರಿ ಬೇಕಿದೆ ಕೇವಲ ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಒಂದು ಪದ ಏನು

1104
01:00:13,000 --> 01:00:15,000
ಆದರೆ ಇಲ್ಲವೋ, ಮಾನವ, ಅದನ್ನು ಕಂಡು

1105
01:00:15,000 --> 01:00:20,000
ನೀವು ಹೇಗೆ ಹೋದರೆ ಪದ "" ನೀವು ಟೈಪ್ ಸಾಧ್ಯವಿಲ್ಲ ಎಂದು ನಮೂದಿಸಿ, ನಮೂದಿಸಿ, ನಮೂದಿಸಿ

1106
01:00:20,000 --> 01:00:23,000
ಮತ್ತು 3 ಅಂಕಗಳನ್ನು, 3 ಅಂಕಗಳನ್ನು, 3 ಅಂಕಗಳನ್ನು, 3 ಅಂಕಗಳನ್ನು.

1107
01:00:23,000 --> 01:00:26,000
ನಾವು bool ಹೊಂದಿಸುವ ಮೂಲಕ ಆ ಪದ ಕಪ್ಪುಪಟ್ಟಿಗೆ ಮಾಡಲು ಬಯಸುವ

1108
01:00:26,000 --> 01:00:29,000
ನೀವು ಈಗಾಗಲೇ ಅದನ್ನು ಕಂಡುಬಂದರೆ ಏಕೆ ನಿಜವಾದ ಗೆ, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ಅವರ

1109
01:00:29,000 --> 01:00:31,000
ಈ ವಿನ್ಯಾಸದಲ್ಲಿ ಇದು ಸುತ್ತುವರಿಯುತ್ತದೆ.

1110
01:00:31,000 --> 01:00:35,000
>> ಈಗ, ಕೆಳಗೆ ಇಲ್ಲಿ ಸ್ಕ್ರ್ಯಾಂಬಲ್ ರಲ್ಲಿ ಡಿಕ್ಷನರಿ ಎಂಬ ಇತರ struct ಇಲ್ಲ.

1111
01:00:35,000 --> 01:00:39,000
ಇಲ್ಲಿ ಆಬ್ಸೆಂಟ್ typedef ಪದ ಏಕೆಂದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ

1112
01:00:39,000 --> 01:00:43,000
ನಾವು, ಒಂದು ನಿಘಂಟು ಕಲ್ಪನೆಯನ್ನು ಕೋಶೀಕರಿಸುತ್ತದೆ ಅಗತ್ಯವಿದೆ

1113
01:00:43,000 --> 01:00:46,000
ಮತ್ತು ಒಂದು ಡಿಕ್ಷನರಿ, ಪದಗಳ ಇಡೀ ಗುಂಪೇ ಹೊಂದಿರುತ್ತದೆ

1114
01:00:46,000 --> 01:00:49,000
ಈ ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುವ, ಮತ್ತು ಹೇಗೆ ಆ ಪದಗಳನ್ನು ಅನೇಕ ಇವೆ?

1115
01:00:49,000 --> 01:00:51,000
ಅಲ್ಲದೆ, ಈ ವೇರಿಯಬಲ್ ಎಂಬ ಗಾತ್ರ ಹೇಳುತ್ತಾರೆ ಯಾವುದೇ.

1116
01:00:51,000 --> 01:00:53,000
ಆದರೆ ನಾವು ಕೇವಲ ಒಂದು ನಿಘಂಟು ಅಗತ್ಯವಿದೆ.

1117
01:00:53,000 --> 01:00:55,000
ನಾವು ಡಿಕ್ಷನರಿ ಎಂಬ ಅಕ್ಷಾಂಶ ಟೈಪ್ ಮಾಡಬೇಕಿಲ್ಲ.

1118
01:00:55,000 --> 01:00:58,000
ನಾವು ಅವರಿಗೆ ಒಂದು ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ಸಿ ತಿರುಗಿದರೆ

1119
01:00:58,000 --> 01:01:03,000
ನೀವು typedef ಹೇಳುತ್ತಿಲ್ಲ ವೇಳೆ, ನೀವು struct ಹೇಳುತ್ತಾರೆ, ನಂತರ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಒಳಗೆ

1120
01:01:03,000 --> 01:01:05,000
ನೀವು ಹೆಸರು ಪುಟ್ ನಂತರ, ನಿಮ್ಮ ಅಸ್ಥಿರ ಪುಟ್.

1121
01:01:05,000 --> 01:01:09,000
ಈ ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂಬ ನಿಘಂಟು ಘೋಷಿಸುವ ಇದೆ

1122
01:01:09,000 --> 01:01:11,000
ಈ ತೋರುತ್ತಿದೆ.

1123
01:01:11,000 --> 01:01:16,000
ಇದಕ್ಕೆ ವಿರುದ್ಧವಾಗಿ, ಈ ಸಾಲುಗಳನ್ನು ಪದ ಎಂಬ ಮರುಬಳಕೆಯ ಅಕ್ಷಾಂಶ ರಚನೆ ರಚಿಸುತ್ತಿರುವ

1124
01:01:16,000 --> 01:01:19,000
ನಾವು ರಚಿಸಿದ ಕೇವಲ ನಿಮಗೆ, ಅನೇಕ ಪ್ರತಿಗಳನ್ನು ರಚಿಸಬಹುದು ಎಂದು

1125
01:01:19,000 --> 01:01:22,000
ವಿದ್ಯಾರ್ಥಿಗಳು ಅನೇಕ ಪ್ರತಿಗಳು.

1126
01:01:22,000 --> 01:01:24,000
>> ಈ ಅಂತಿಮವಾಗಿ ನಮಗೆ ಏನು ಮಾಡಬೇಕೆಂದು ಅವಕಾಶ ಇಲ್ಲ?

1127
01:01:24,000 --> 01:01:30,000
ನನ್ನ ಸರಳ ಕಾಲದಿಂದಲೂ, ಸೇ 'ಒಂದು ಸರಳ ಉದಾಹರಣೆ ನೋಡೋಣ, ಮತ್ತೆ ಹೋಗಿ ಅವಕಾಶ

1128
01:01:30,000 --> 01:01:34,000
ಮತ್ತು compare1.c, ನ ಹೇಳಲು ಅವಕಾಶ ನನಗೆ ತೆರೆದುಕೊಳ್ಳಲು ಅವಕಾಶ.

1129
01:01:34,000 --> 01:01:38,000
ಕೈಯಲ್ಲಿ ಇಲ್ಲಿ ಸಮಸ್ಯೆ ವಾಸ್ತವವಾಗಿ ಹಿಂದೆ ಪೀಲ್ ಆಗಿದೆ

1130
01:01:38,000 --> 01:01:41,000
ಒಂದು ತಂತುವಿನ ಪದರ ಮತ್ತು ಈ ತರಬೇತಿ ಚಕ್ರಗಳು ಏರಲು ಪ್ರಾರಂಭಿಸಿ

1131
01:01:41,000 --> 01:01:44,000
ಇದು ಒಂದು ವಾಕ್ಯವನ್ನು ಎಲ್ಲಾ ಈ ಬಾರಿ ತಿರುಗಿದರೆ ಏಕೆಂದರೆ

1132
01:01:44,000 --> 01:01:47,000
ನಾವು ವಾರಕ್ಕೆ 1 ಕೇವಲ ಅಡ್ಡಹೆಸರು ಭರವಸೆ ಎಂದು,

1133
01:01:47,000 --> 01:01:51,000
ಒಂದು ಸಮಾನಾರ್ಥಕ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಗೂಢ ಕಾಣುವ ಯಾವುದನ್ನಾದರೂ CS50 ಲೈಬ್ರರಿಯಿಂದ,

1134
01:01:51,000 --> 01:01:53,000
ಚಾರ್ *, ಮತ್ತು ನಾವು ಮೊದಲು ಈ ನಕ್ಷತ್ರ ನೋಡಿದ್ದೇವೆ.

1135
01:01:53,000 --> 01:01:55,000
ನಾವು ಕಡತಗಳನ್ನು ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಕಂಡಿತು.

1136
01:01:55,000 --> 01:01:59,000
>> ನಾವು ಈಗ ಕೆಲವು ಬಾರಿ ಈ ವಿವರ ಅಡಗಿಕೊಂಡು ನಾವು ಏಕೆ ಈಗ ನೋಡೋಣ.

1137
01:01:59,000 --> 01:02:02,000
ಇಲ್ಲಿ compare1.c ಎಂಬ ಫೈಲ್ ಆಗಿದೆ

1138
01:02:02,000 --> 01:02:07,000
ಮತ್ತು ಇದು ಸ್ಪಷ್ಟವಾಗಿ, ರು ಮತ್ತು T, 2 ತಂತಿಗಳು ಬಳಕೆದಾರರನ್ನು ಕೇಳುತ್ತದೆ

1139
01:02:07,000 --> 01:02:11,000
ನಂತರ ಅದನ್ನು, ಸಾಲು 26 ರಲ್ಲಿ ಸಮಾನತೆ ಆ ತಂತಿಗಳು ಹೋಲಿಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ

1140
01:02:11,000 --> 01:02:14,000
ಅವರು ಹೇಳುತ್ತಾರೆ ಸಮಾನ ಇಂತಹ ಮತ್ತು, "ನೀವು, ಅದೇ ವಿಷಯ ಟೈಪ್"

1141
01:02:14,000 --> 01:02:17,000
ಮತ್ತು ಅವರು ಸಮಾನರಲ್ಲ ಅದು "ನೀವು ಬೇರೆ ವಸ್ತುಗಳನ್ನು ಟೈಪಿಸಿದ." ಹೇಳುತ್ತಾರೆ

1142
01:02:17,000 --> 01:02:19,000
ನನ್ನ ಮುಂದೆ ಹೋಗಿ ಈ ಪ್ರೋಗ್ರಾಂ ಅವಕಾಶ.

1143
01:02:19,000 --> 01:02:23,000
ನನ್ನ ಮೂಲ ಕೋಶಕ್ಕೆ ಹೋಗಿ ಅವಕಾಶ, ಒಂದು compare1 ಮಾಡಿ. ಪರವಾಗಿಲ್ಲ ಸಂಗ್ರಹಿಸಿದರು.

1144
01:02:23,000 --> 01:02:25,000
ನನಗೆ compare1 ಔಟ್ ಲೆಟ್.

1145
01:02:25,000 --> 01:02:27,000
ನಾನು, ಜೂಮ್ ಅನ್ನು ನಮೂದಿಸಿ.

1146
01:02:27,000 --> 01:02:29,000
ಏನೋ ಸೇ. ಹಲೋ.

1147
01:02:29,000 --> 01:02:32,000
ನಾನು ಮತ್ತೊಮ್ಮೆ ಏನೋ ಹೇಳುತ್ತೇನೆ. ಹಲೋ.

1148
01:02:32,000 --> 01:02:34,000
ನಾನು ಖಂಡಿತವಾಗಿ ವಿಭಿನ್ನ ವಿಷಯಗಳನ್ನು ಟೈಪ್ ಮಾಡಲಿಲ್ಲ.

1149
01:02:34,000 --> 01:02:37,000
>> ನನ್ನನ್ನು ಮತ್ತೆ ಈ ಪ್ರಯತ್ನಿಸೋಣ. ಬೈ ಬೈ.

1150
01:02:37,000 --> 01:02:40,000
ಖಂಡಿತವಾಗಿ ವಿಭಿನ್ನ ಅಲ್ಲ, ಇಲ್ಲಿ ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಆದ್ದರಿಂದ?

1151
01:02:40,000 --> 01:02:44,000
ಅಲ್ಲದೆ, ನಿಜವಾಗಿಯೂ ಸಾಲಿನ 26 ಯಾವ ಹೋಲಿಸಿದರೆ ಮಾಡಲಾಗುತ್ತಿದೆ?

1152
01:02:44,000 --> 01:02:46,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

1153
01:02:46,000 --> 01:02:49,000
ಹೌದು, ಆದ್ದರಿಂದ ಒಂದು ಸ್ಟ್ರಿಂಗ್, ಮಾಹಿತಿ ಪ್ರಕಾರ, ಒಂದು ಬಿಳಿ ಸುಳ್ಳು ರೀತಿಯ ಎಂದು ಔಟ್ ಆರಂಭಿಸುತ್ತದೆ.

1154
01:02:49,000 --> 01:02:53,000
ಸರಣಿ ಒಂದು ಚಾರ್ * ಹೊಂದಿದೆ, ಆದರೆ ಒಂದು ಚಾರ್ * ಏನು?

1155
01:02:53,000 --> 01:02:56,000
ಎ ಚಾರ್ *, ಅವರು ಹೇಳಿದಂತೆ, ಒಂದು ಸೂಚಿಯಾಗಿದೆ

1156
01:02:56,000 --> 01:03:00,000
ಮತ್ತು ಒಂದು ಪಾಯಿಂಟರ್, ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಒಂದು ವಿಳಾಸ

1157
01:03:00,000 --> 01:03:05,000
ಮೊತ್ತದ ಮೆಮೊರಿ ಸ್ಥಳ, ಮತ್ತು ನೀವು ಹಲೋ ಒಂದು ಪದ ಬೆರಳಚ್ಚಿಸಿದ ಎಂದು ಸಂಭವಿಸಿದಾಗ

1158
01:03:05,000 --> 01:03:08,000
ತಂತಿಗಳ ಹಿಂದಿನ ಚರ್ಚೆಗಳಿಂದ ಮರುಪಡೆಯಲು

1159
01:03:08,000 --> 01:03:16,000
ಈ ಪದವು ನಂತಹ ಹಲೋ ಹೊಂದಿದೆ.

1160
01:03:16,000 --> 01:03:19,000
ಹಲೋ ಒಂದು ಪದ ನಿರೂಪಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೆನಪಿಡಿ

1161
01:03:19,000 --> 01:03:22,000
ಈ ತರಹದ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾಹಿತಿ

1162
01:03:22,000 --> 01:03:25,000
ಮತ್ತು ನಂತರ ಕೊನೆಯಲ್ಲಿ ವಿಶೇಷ ಅಕ್ಷರದೊಂದಿಗೆ, ಶೂನ್ಯ ಗುಣವೆಂದರೆ

1163
01:03:25,000 --> 01:03:27,000
\ ಸೂಚಿಸುತ್ತದೆ ಎಂದು.

1164
01:03:27,000 --> 01:03:29,000
ಸ್ಟ್ರಿಂಗ್ ನಿಜವಾಗಿ ಏನು?

1165
01:03:29,000 --> 01:03:32,000
, ಈ ಮೆಮೊರಿಯ ಬಹು ಭಾಗಗಳಲ್ಲಿ ಗಮನಿಸಿ

1166
01:03:32,000 --> 01:03:36,000
ನೀವು ಇಡೀ ಅಕ್ಷರ ಮೂಲಕ ನೋಡಿದಾಗ ಒಮ್ಮೆ ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಇದು ಕೊನೆಯಲ್ಲಿ ಕೇವಲ ಕರೆಯಲಾಗುತ್ತದೆ

1167
01:03:36,000 --> 01:03:38,000
ವಿಶೇಷ ಶೂನ್ಯಚಿಹ್ನೆ ಹುಡುಕುತ್ತಿರುವ.

1168
01:03:38,000 --> 01:03:41,000
ಆದರೆ ಈ ನನ್ನ ಕಂಪ್ಯೂಟರ್ನ ಮೆಮೊರಿ ರಿಂದ ಮೆಮೊರಿಯ ಒಂದು ಚಂಕ್ ವೇಳೆ,

1169
01:03:41,000 --> 01:03:44,000
ಈಗ ಕ್ರಮವಿಲ್ಲದ ಈ ಸಾಲನ್ನು ಕೇವಲ ಅದೃಷ್ಟ ದೊರೆತಿದೆ, ಹೇಳುತ್ತಾರೆ

1170
01:03:44,000 --> 01:03:47,000
ಮತ್ತು ನನ್ನ ಕಂಪ್ಯೂಟರ್ನ RAM ನ ಅತ್ಯಂತ ಆರಂಭದಲ್ಲಿ ಸ್ಥಾನ ಪಡೆದುಕೊಂಡಿದೆ.

1171
01:03:47,000 --> 01:03:54,000
ಈ ಬೈಟ್ 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> ನಾನು GetString ಸ್ವಲ್ಪ ಹೇಳಿ ನಾನು ಸ್ಟ್ರಿಂಗ್ ರು = GetString ಮಾಡಿದಾಗ

1173
01:04:02,000 --> 01:04:04,000
ನಿಜವಾಗಿ ಏನು ಹಿಂದಿರುಗಿಸುವ ವಿಶೇಷವೇನು?

1174
01:04:04,000 --> 01:04:08,000
ಈ ಹಿಂದೆ ಅನೇಕ ವಾರಗಳ ಕಾಲ, ಯಾವ ನಿಜವಾಗಿಯೂ ರು ಶೇಖರವಾಗುತ್ತದೆ ವಿಶೇಷವೇನು

1175
01:04:08,000 --> 01:04:13,000
ವಸ್ತುತಃ ಈ ಸಾಲನ್ನು, ಆದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಏನು ಶೇಖರವಾಗುತ್ತದೆ ಪಡೆದುಕೊಳ್ಳಬಹುದಾಗಿದೆ

1176
01:04:13,000 --> 01:04:18,000
GetString ನಿಜವಾಗಿ ಏನು ಕಾರಣ ಸಂಖ್ಯೆ 0

1177
01:04:18,000 --> 01:04:20,000
ಇದು ದೈಹಿಕವಾಗಿ ಸ್ಟ್ರಿಂಗ್ ಮರಳಲು ಇಲ್ಲ ಇದೆ.

1178
01:04:20,000 --> 01:04:22,000
ಸಹ ನಿಜವಾಗಿಯೂ ಭಾವನಾತ್ಮಕ ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

1179
01:04:22,000 --> 01:04:24,000
ಇದು ರಿಟರ್ನ್ ಒಂದು ಸಂಖ್ಯೆ ಏನು.

1180
01:04:24,000 --> 01:04:28,000
ಆ ಸಂಖ್ಯೆ, ನೆನಪಿಗಾಗಿ ಹಲೋ ವಿಳಾಸ

1181
01:04:28,000 --> 01:04:32,000
ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ರು ನಂತರ, ನಾವು ಮತ್ತೆ ಪೀಲ್ ಈ ಪದರ, ಸ್ಟ್ರಿಂಗ್ ನಿಜವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ವೇಳೆ.

1182
01:04:32,000 --> 01:04:35,000
ಇದು ಕೇವಲ CS50 ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಒಂದು ಸರಳೀಕರಣ ಇಲ್ಲಿದೆ.

1183
01:04:35,000 --> 01:04:38,000
>> ಈ ನಿಜವಾಗಿಯೂ ಚಾರ್ * ಎಂಬ ವಿಷಯ.

1184
01:04:38,000 --> 01:04:41,000
ಏನು ನಿನ್ನ ಹಾಗೆ, ಒಂದು ಪದ, ಏಕೆಂದರೆ ಚಾರ್ ಸಮಂಜಸವೇ?

1185
01:04:41,000 --> 01:04:44,000
ಅಲ್ಲದೆ, ಇದು ಅಕ್ಷರಗಳನ್ನು ಒಂದು ಸರಣಿ, ಅಕ್ಷರಗಳನ್ನು ಸರಣಿಯ.

1186
01:04:44,000 --> 01:04:47,000
ಚಾರ್ *, ಒಂದು ಪಾತ್ರದ ವಿಳಾಸಕ್ಕೆ ಅರ್ಥ

1187
01:04:47,000 --> 01:04:50,000
ಆದ್ದರಿಂದ ಅದರ ಸ್ಟ್ರಿಂಗ್ ಮರಳಲು ಅರ್ಥವೇನು?

1188
01:04:50,000 --> 01:04:53,000
ಸ್ಟ್ರಿಂಗ್ ಹಿಂದಿರುಗಿದ ಒಂದು ಉತ್ತಮ, ಸರಳ ಮಾರ್ಗವಾಗಿದೆ

1189
01:04:53,000 --> 01:04:57,000
ಬದಲಿಗೆ ನಾನು 5 ಅಥವಾ 6 ವಿವಿಧ ಬೈಟ್ಗಳು ಹಿಂದಿರುಗಿ ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ ಪ್ರಯತ್ನಿಸಿ

1190
01:04:57,000 --> 01:05:01,000
ನನಗೆ ಇದು ಬೈಟ್ ವಿಳಾಸಕ್ಕೆ ಹಿಂದಿರುಗಲು ಅವಕಾಶ?

1191
01:05:01,000 --> 01:05:03,000
ಮೊದಲ ಒಂದು.

1192
01:05:03,000 --> 01:05:06,000
ಅಂದರೆ, ನೀವು ನೆನಪಿನಲ್ಲಿ ಒಂದು ಪಾತ್ರದ ವಿಳಾಸಕ್ಕೆ ನೀಡಲು ಅವಕಾಶ.

1193
01:05:06,000 --> 01:05:10,000
ಎಂದು, ಚಾರ್ * ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಮೆಮೊರಿ ಒಂದೇ ಪಾತ್ರದ ವಿಳಾಸಕ್ಕೆ ಇಲ್ಲಿದೆ.

1194
01:05:10,000 --> 01:05:12,000
ಆ ವೇರಿಯಬಲ್ ರು ಕಾಲ್.

1195
01:05:12,000 --> 01:05:15,000
ನಾನು ನಿರಂಕುಶವಾಗಿ ಹೇಳಿದರು ಇದು ನಿರ್ದಿಷ್ಟ ವಿಳಾಸಕ್ಕೆ, 0 ಎಂದು ರು ರಲ್ಲಿ ಅಂಗಡಿ,

1196
01:05:15,000 --> 01:05:19,000
ಕೇವಲ ವಿಷಯಗಳನ್ನು ಸರಳ ಇರಿಸಿಕೊಳ್ಳಲು, ಆದರೆ ವಾಸ್ತವದಲ್ಲಿ ಅದು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆಯ.

1197
01:05:19,000 --> 01:05:21,000
>> ಒಂದು ನಿಮಿಷ ನಿಲ್ಲಿ.

1198
01:05:21,000 --> 01:05:23,000
ನೀವು ಮಾತ್ರ ನನ್ನನ್ನು ಮೊದಲ ಪಾತ್ರದ ವಿಳಾಸಕ್ಕೆ ನೀಡುವ ಬಳಸುತ್ತಿದ್ದರೆ, ಹೇಗೆ ನಾನು ವಿಳಾಸಕ್ಕೆ ಏನು ಗೊತ್ತು

1199
01:05:23,000 --> 01:05:25,000
ಎರಡನೇ ಪಾತ್ರದ, ಮೂರನೇ, ನಾಲ್ಕನೇ ಮತ್ತು ಐದನೇ?

1200
01:05:25,000 --> 01:05:27,000
[ಕೇಳಿಸುವುದಿಲ್ಲ ವಿದ್ಯಾರ್ಥಿ]

1201
01:05:27,000 --> 01:05:31,000
ಸರಣಿಯ ಅಂತ್ಯಕ್ಕೆ ಈ HANDY ಟ್ರಿಕ್ ಮೂಲಕ ಅಲ್ಲಿ ನೀವು ಮಾತ್ರ ತಿಳಿದಿದೆ

1202
01:05:31,000 --> 01:05:35,000
ಆದ್ದರಿಂದ ನಿಮ್ಮಂತಹ printf ಏನೋ ಬಳಸಿದಾಗ, ಏನು printf ಅಕ್ಷರಶಃ, ಅದರ ಚರ್ಚೆಯಂತೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

1203
01:05:35,000 --> 01:05:39,000
ಈ% ರು ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಅನ್ನು ಸ್ಮರಿಸುತ್ತಾರೆ, ಮತ್ತು ನಂತರ ನೀವು ಹಾದು

1204
01:05:39,000 --> 01:05:41,000
ಸ್ಟ್ರಿಂಗ್ ಸಂಗ್ರಹಿಸಲು ಎಂದು ವೇರಿಯಬಲ್.

1205
01:05:41,000 --> 01:05:47,000
ನೀವು ನಿಜವಾಗಿಯೂ ಹಾದುಹೋಗುವ ನೀವು ಸ್ಟ್ರಿಂಗ್ ಮೊದಲ ಪಾತ್ರದ ವಿಳಾಸ.

1206
01:05:47,000 --> 01:05:50,000
Printf ನಂತರ, ಆ ವಿಳಾಸಕ್ಕೆ ಸಿಗದಿದ್ದಾಗ ಲೂಪ್ ಅಥವಾ ಸ್ವಲ್ಪ ಲೂಪ್ ಒಂದು ಬಳಸುತ್ತದೆ

1207
01:05:50,000 --> 01:05:53,000
ಉದಾಹರಣೆಗೆ, 0, ಆದ್ದರಿಂದ, ನನಗೆ ಈಗ ಈ ಮಾಡಿ

1208
01:05:53,000 --> 01:06:02,000
printf ("% s \ n" ರು);

1209
01:06:02,000 --> 01:06:07,000
ನಾನು ಕಾಲ್ ಮಾಡಿದಾಗ printf ("% s \ n" ರು); ಎಂಬುದನ್ನು ನಾನು ಜೊತೆ printf ಒದಗಿಸುವ ನಾನು

1210
01:06:07,000 --> 01:06:13,000
ಈ ಅನಿಯಂತ್ರಿತ ಸಂದರ್ಭದಲ್ಲಿ ಎಚ್ ಇದು ರು ಮೊದಲ ಪಾತ್ರದ ವಿಳಾಸಕ್ಕೆ, ಆಗಿದೆ

1211
01:06:13,000 --> 01:06:16,000
>> ಹೇಗೆ printf ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲು ನಿಖರವಾಗಿ ಏನು ತಿಳಿದಿದೆಯೇ?

1212
01:06:16,000 --> 01:06:19,000
ಜಾರಿಗೆ ವ್ಯಕ್ತಿ printf ಲೂಪ್ ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಅಥವಾ ಜಾರಿಗೆ

1213
01:06:19,000 --> 01:06:23,000
ಈ ಪಾತ್ರದ ವಿಶೇಷ ಶೂನ್ಯಚಿಹ್ನೆ ಸಮನಾಗಿರಬೇಕು ಎಂದು ಹೇಳುತ್ತಾರೆ?

1214
01:06:23,000 --> 01:06:25,000
ಅಲ್ಲ, ಇದು ಮುದ್ರಿಸುತ್ತದೆ. ಹೇಗೆ ಈ ಬಗ್ಗೆ?

1215
01:06:25,000 --> 01:06:28,000
ಅದನ್ನು ಮುದ್ರಿಸಲು ಅಲ್ಲ, ಅದನ್ನು ಮುದ್ರಿಸಲು ಅದನ್ನು ಮುದ್ರಿಸಿ, ಅದನ್ನು ಮುದ್ರಿಸಿ.

1216
01:06:28,000 --> 01:06:32,000
ಓಹ್, ಈ ಒಂದು ವಿಶೇಷ. ಮುದ್ರಣ ನಿಲ್ಲಿಸಿ ಮತ್ತು ಬಳಕೆದಾರ ಹಿಂತಿರುಗಿ.

1217
01:06:32,000 --> 01:06:35,000
ಮತ್ತು, ಅಕ್ಷರಶಃ HOOD ಕೆಳಗೆ ನಡೆಯುತ್ತಿದೆ ಮಾಡಿದ ಅಷ್ಟೆ

1218
01:06:35,000 --> 01:06:38,000
ಮತ್ತು, ಒಂದು ವರ್ಗದ ಮೊದಲ ದಿನದಲ್ಲಿ ಜೀರ್ಣಿಸಿಕೊಳ್ಳಲು ಸಂಗತಿಯೇ

1219
01:06:38,000 --> 01:06:43,000
ಆದರೆ ಈಗ ಅದನ್ನು ನಿಜವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಎಲ್ಲ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್ಸ್ ನ

1220
01:06:43,000 --> 01:06:46,000
ಎಂದು, ನಮ್ಮ ಗಣಕದ ಮೆಮೊರಿಯ ಒಳಗೆ ನಡೆದುಕೊಂಡುಬರುತ್ತಿರುವುದರಿಂದ

1221
01:06:46,000 --> 01:06:49,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು ಸ್ವಲ್ಪ ಸಹಾಯದಿಂದ ಈ ಅಂತರದಲ್ಲಿ ಕೀಟಲೆ ವಿಲ್

1222
01:06:49,000 --> 01:06:51,000
ಸ್ಟ್ಯಾನ್ಫೋರ್ಡ್ ನಮ್ಮ ಸ್ನೇಹಿತರ ಒಂದರಿಂದ.

1223
01:06:51,000 --> 01:06:56,000
>> ಸ್ಟ್ಯಾನ್ಫೋರ್ಡ್ ಪ್ರಾಧ್ಯಾಪಕರಾಗಿದ್ದರು ನಿಕ್ Parlante ಈ ಅದ್ಭುತ ವಿಡಿಯೋ ಅನುಕ್ರಮ ಮಾಡಿದ್ದಾರೆ

1224
01:06:56,000 --> 01:06:58,000
ಪರಿಚಯಿಸಿದ ವಿಭಿನ್ನ ಭಾಷೆಗಳ ಎಲ್ಲಾ ರೀತಿಯ ನಿಂದ

1225
01:06:58,000 --> 01:07:00,000
ಈ ಕಡಿಮೆ Claymation ಪಾತ್ರ Binky.

1226
01:07:00,000 --> 01:07:03,000
ನೀವು ಕೆಲವೇ ಎರಡನೇ ರಹಸ್ಯ ಪೂರ್ವವೀಕ್ಷಣೆಯನ್ನು ರಲ್ಲಿ ಕೇಳಲು ಬಗ್ಗೆ ನೀವು ಧ್ವನಿ

1227
01:07:03,000 --> 01:07:05,000
ಒಂದು ಸ್ಟ್ಯಾನ್ಫೋರ್ಡ್ ಪ್ರೊಫೆಸರ್, ಮತ್ತು ನೀವು ಬರುತ್ತಿದೆ

1228
01:07:05,000 --> 01:07:07,000
ಈ ಹಕ್ಕನ್ನು ಮಾತ್ರ 5 ಅಥವಾ 6 ಸೆಕೆಂಡುಗಳ ಈಗ,

1229
01:07:07,000 --> 01:07:09,000
ಆದರೆ ಇಂದು ನಾವು ನಿರ್ಧರಿಸಬಹುದು ವಿಲ್ ಮೇಲೆ ಟಿಪ್ಪಣಿ

1230
01:07:09,000 --> 01:07:11,000
ಮತ್ತು ಬುಧವಾರ ಆರಂಭವಾಗುತ್ತದೆ.

1231
01:07:11,000 --> 01:07:15,000
ನಾನು Binky, ಅವಲೋಕನದಲ್ಲಿ ಪಾಯಿಂಟರ್ ಫನ್ ನೀಡಿ.

1232
01:07:15,000 --> 01:07:18,000
[♪ ♪ ಸಂಗೀತ] [ಪ್ರೊಫೆಸರ್ Parlante] ಹೇ, Binky.

1233
01:07:18,000 --> 01:07:21,000
ಎದ್ದೇಳಿ. ಇದು ಪಾಯಿಂಟರ್ ಮೋಜಿಗಾಗಿ ಸಮಯ.

1234
01:07:21,000 --> 01:07:24,000
[Binky] ಎಂದು ಯಾವುದು? ಪಾಯಿಂಟರ್ಸ್ ಬಗ್ಗೆ ತಿಳಿಯಿರಿ?

1235
01:07:24,000 --> 01:07:26,000
ಓಹ್, GOODY!

1236
01:07:26,000 --> 01:07:29,000
>> ನಾವು ಬುಧವಾರ ನೀವು ನೋಡಬಹುದು.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]