1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [ರಿವ್ಯೂ] [ರಸಪ್ರಶ್ನೆ 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi ರಾಸ್, ಟಾಮಿ MacWilliam, ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್, ಜೋಸೆಫ್ ಓಂಗ್] [ಹಾರ್ವರ್ಡ್ ವಿಶ್ವವಿದ್ಯಾಲಯ]

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

4
00:00:08,000 --> 00:00:10,000
>> ಹೇ, ಎಲ್ಲರೂ.

5
00:00:10,000 --> 00:00:15,000
ಈ ಬುಧವಾರ ನಡೆಯುತ್ತಿದೆ ಇದು ರಸಪ್ರಶ್ನೆ 0, ರಿವ್ಯೂ ಅಧಿವೇಶನದ ಸ್ವಾಗತ.

6
00:00:15,000 --> 00:00:19,000
ನಾವು ಟುನೈಟ್ ಮಾಡಲು ನೀನು ಏನು, ನಾನು, 3 ಇತರ TFS ಜೊತೆ ಆಮ್

7
00:00:19,000 --> 00:00:24,000
ಮತ್ತು ಒಟ್ಟಿಗೆ ನಾವು ಇಲ್ಲಿಯವರೆಗೆ ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಿದ ಯಾವ ಒಂದು ವಿಮರ್ಶೆ ಮೂಲಕ ಹೋಗಲು ನೀನು.

8
00:00:24,000 --> 00:00:27,000
ಇದು 100% ವ್ಯಾಪಕವಾದ ಹಿಂದಿರುಗಬಹುದೆಂದು, ಆದರೆ ನೀವು ಒಂದು ಉತ್ತಮ ಕಲ್ಪನೆಯನ್ನು ನೀಡುತ್ತದೆ

9
00:00:27,000 --> 00:00:31,000
ನೀವು ಈಗಾಗಲೇ ಕೆಳಗೆ ಏನು ಮತ್ತು ಯಾವ ನೀವು ಇನ್ನೂ ಬುಧವಾರ ಮೊದಲು ಅಧ್ಯಯನ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

10
00:00:31,000 --> 00:00:34,000
ನಾವು ಜೊತೆಗೆ ನೀನು ಮತ್ತು ಪ್ರಶ್ನೆಗಳನ್ನು ನಿಮ್ಮ ಕೈ ಹೆಚ್ಚಿಸಲು ಹಿಂಜರಿಯಬೇಡಿ

11
00:00:34,000 --> 00:00:38,000
ಆದರೆ ನಾವು ಸಮಯದಲ್ಲಿ ಒಂದು ಸ್ವಲ್ಪ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ ಕೊನೆಯ

12
00:00:38,000 --> 00:00:41,000
ನಾವು ಸಾಮಾನ್ಯ ಪ್ರಶ್ನೆಗಳನ್ನು ಮಾಡಲು ಬಡಕಲ ಕೆಲವು ನಿಮಿಷಗಳ ಮೂಲಕ ಪಡೆಯಲು ವೇಳೆ,

13
00:00:41,000 --> 00:00:47,000
ಆದ್ದರಿಂದ ಮನಸ್ಸು ಆ ಇರಿಸಿಕೊಳ್ಳಲು, ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು ವೀಕ್ 0 ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸಲು ನೀನು.

14
00:00:47,000 --> 00:00:50,000
>> ನಾವು ಮೊದಲು [0 ರಿವ್ಯೂ ಕ್ವಿಜ್!] [ಭಾಗ 0] [Lexi ರಾಸ್] ಆದರೆ ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡುವುದು

15
00:00:50,000 --> 00:00:53,000
ರಸಪ್ರಶ್ನೆಯ ಜಾರಿ.

16
00:00:53,000 --> 00:00:55,000
>> [ಲಾಜಿಸ್ಟಿಕ್ಸ್] [ರಸಪ್ರಶ್ನೆ ಉಪನ್ಯಾಸ ಬದಲಾಗಿ ಬುಧವಾರ 10/10 ರಂದು ನಡೆಯುತ್ತದೆ]

17
00:00:55,000 --> 00:00:57,000
>> [(ವಿವರಗಳಿಗಾಗಿ http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf ನೋಡಿ)] ಇದು ಬುಧವಾರ, ಅಕ್ಟೋಬರ್ 10 ರಂದು ಹೊಂದಿದೆ.

18
00:00:57,000 --> 00:01:00,000
>> ಈ ಬುಧವಾರ, ಮತ್ತು ನೀವು ಇಲ್ಲಿ ಈ URL ಗೆ ಹೋದರೆ,

19
00:01:00,000 --> 00:01:03,000
ಇದು ಲಿಂಕ್ CS50.net-ಇಲ್ಲ 'ಗಳ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದು ಇದು

20
00:01:03,000 --> 00:01:06,000
ನೀವು ಆಧರಿಸಿ ಹೋಗಲು ಅಲ್ಲಿ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನೋಡಬಹುದು

21
00:01:06,000 --> 00:01:10,000
ನಿಮ್ಮ ಕೊನೆಯ ಹೆಸರು ಅಥವಾ ಶಾಲೆಯ ಅನುಸರಣೆ ಹಾಗೂ

22
00:01:10,000 --> 00:01:14,000
ಅದರ ಬಗ್ಗೆ ನಿಖರವಾಗಿ ರಸಪ್ರಶ್ನೆ ನೀವು ಪಡೆಯಲು ನೀನು ಆ ಕವರ್ ಮತ್ತು ಪ್ರಶ್ನೆಗಳ ವಿಧಗಳು ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ.

23
00:01:14,000 --> 00:01:19,000
ನೀವು ವಿಭಾಗದಲ್ಲಿ ರಸಪ್ರಶ್ನೆ ರಿವ್ಯೂ ಅವಕಾಶ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ,

24
00:01:19,000 --> 00:01:21,000
ನಿಮ್ಮ TFS, ಕೆಲವು ಅಭ್ಯಾಸ ಸಮಸ್ಯೆಗಳನ್ನು ಹೋಗುವಾಗ ಮಾಡಬೇಕು

25
00:01:21,000 --> 00:01:29,000
ಮತ್ತು ನೀವು ಇನ್ನೂ ರಸಪ್ರಶ್ನೆ ಅಪ್ ಅಧ್ಯಯನ ಅಗತ್ಯವಿದೆ ಅಲ್ಲಿ ನೋಡಲು ಇನ್ನೊಂದು ಒಳ್ಳೆಯ ಅವಕಾಶ ಇಲ್ಲಿದೆ.

26
00:01:29,000 --> 00:01:32,000
ಬಿಟ್ಸ್ 'ಎನ್' ಒಂದುಪುಟದಗಾತ್ರ ಜೊತೆ ಆರಂಭದಲ್ಲಿ ಆರಂಭಿಸೋಣ.

27
00:01:32,000 --> 00:01:35,000
ಒಂದು ಬಿಟ್ ಕೇವಲ 0 ಅಥವಾ 1, ರಿಮೆಂಬರ್

28
00:01:35,000 --> 00:01:38,000
ಮತ್ತು ಒಂದು ಬೈಟ್ ಆ ಬಿಟ್ಗಳ 8 ಸಂಗ್ರಹವಾಗಿದೆ.

29
00:01:38,000 --> 00:01:42,000
ಇಲ್ಲಿಯೇ ಬಿಟ್ಗಳ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ನೋಡೋಣ.

30
00:01:42,000 --> 00:01:44,000
ನಾವು ಅಲ್ಲಿ ಎಷ್ಟು ಬಿಟ್ಗಳ ಔಟ್ ಲೆಕ್ಕಾಚಾರ ಸಾಧ್ಯವಾಗುತ್ತದೆ.

31
00:01:44,000 --> 00:01:48,000
ನಾವು ಲೆಕ್ಕ ಅಲ್ಲಿ ಅವುಗಳಲ್ಲಿ 8, ಎಂಟು 0 ಅಥವಾ 1 ಘಟಕಗಳು ಕೇವಲ ಇಲ್ಲ.

32
00:01:48,000 --> 00:01:51,000
ಮತ್ತು ರಿಂದ 8 ಬಿಟ್ಗಳು, 1 ಬೈಟ್ ಎಂದು, ಇಲ್ಲ

33
00:01:51,000 --> 00:01:53,000
ಮತ್ತು ಅವರ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಪರಿವರ್ತಿಸಲು ಅವಕಾಶ.

34
00:01:53,000 --> 00:01:58,000
ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಬೇಸ್ 16, ಮತ್ತು ಪರಿವರ್ತಿಸುವುದು ಬಹಳ ಸುಲಭ

35
00:01:58,000 --> 00:02:01,000
ಅವಳಿ ಒಂದು ಸಂಖ್ಯೆ, ಇದು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಒಂದು ಸಂಖ್ಯೆಗೆ, ಅಂದರೆ ಏನು.

36
00:02:01,000 --> 00:02:04,000
ನಾವು ಎಲ್ಲಾ ನಾವು, 4 ಗುಂಪುಗಳನ್ನು ನೋಡಿ ಆಗಿದೆ

37
00:02:04,000 --> 00:02:07,000
ಮತ್ತು ನಾವು ಸರಿಯಾದ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕಿಯ ಅವುಗಳನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ.

38
00:02:07,000 --> 00:02:11,000
ನಾವು 0011, 4 ಬಲ ಅತ್ಯಂತ ಗುಂಪು ಪ್ರಾರಂಭಿಸಿ.

39
00:02:11,000 --> 00:02:16,000
ಆದ್ದರಿಂದ ಒಟ್ಟಿಗೆ 3 ಮಾಡುತ್ತದೆ, ಒಂದು 1 ಮತ್ತು 2 ಎಂದು ವಿಶೇಷವೇನು.

40
00:02:16,000 --> 00:02:19,000
ಮತ್ತು ನಂತರ 4 ಇತರೆ ಬ್ಲಾಕ್ ನೋಡೋಣ.

41
00:02:19,000 --> 00:02:24,000
1101. ಒಂದು 1, 4, ಹಾಗೂ ಒಂದು 8 ಎಂದು ವಿಶೇಷವೇನು.

42
00:02:24,000 --> 00:02:28,000
ಒಟ್ಟಿಗೆ ಎಂದು ಡಿ ಮಾಡುತ್ತದೆ, 13 ಎಂದು ವಿಶೇಷವೇನು

43
00:02:28,000 --> 00:02:32,000
ಮತ್ತು ನಾವು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ನಾವು ಕೇವಲ 9 ಮೂಲಕ 0 ಕಾಣುವುದಿಲ್ಲ ನೆನಪು ಮಾಡುತ್ತೇವೆ.

44
00:02:32,000 --> 00:02:36,000
ನಾವು, ಆದ್ದರಿಂದ 9 ನಂತರ, ಎಫ್ ಮೂಲಕ ಒಂದು 10 ಅನುರೂಪವಾಗಿಯೂ 0 ಹೋಗಿ,

45
00:02:36,000 --> 00:02:40,000
ಎಫ್ 15 ಅಲ್ಲಿ 11 ಬಿ, ಎಟ್ ಇತ್ಯಾದಿ.

46
00:02:40,000 --> 00:02:44,000
ಇಲ್ಲಿ 13, ಡಿ ಆಗಿದೆ

47
00:02:44,000 --> 00:02:49,000
ಆದ್ದರಿಂದ ನಾವು ಎಲ್ಲಾ ನಾವು ವಾಸ್ತವವಾಗಿ ದಶಮಾಂಶ ಮತಾಂತರಗೊಳ್ಳಲು

48
00:02:49,000 --> 00:02:52,000
2 ಒಂದು ಶಕ್ತಿಯಾಗಿ ಪ್ರತಿ ಸ್ಥಾನವನ್ನು ಚಿಕಿತ್ಸೆ.

49
00:02:52,000 --> 00:02:58,000
ಒಂದು 1, 2 ಒಂದು, ಶೂನ್ಯ 4s, ಶೂನ್ಯ 8s, ಒಂದು 16, ಎಟ್ ಇತ್ಯಾದಿ, ಅವರ

50
00:02:58,000 --> 00:03:03,000
ಮತ್ತು ನಿಮ್ಮ ತಲೆ ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸ್ವಲ್ಪ ಕಷ್ಟ, ಆದರೆ ಮುಂದಿನ ಸ್ಲೈಡ್ ಹೋಗಿ ವೇಳೆ

51
00:03:03,000 --> 00:03:05,000
ನಾವು ಉತ್ತರವನ್ನು ನೋಡಬಹುದು.

52
00:03:05,000 --> 00:03:09,000
>> ಮೂಲಭೂತವಾಗಿ ನಾವು ಎಡ ಮತ್ತೆ ಬಲಕ್ಕೆ ಅಡ್ಡಲಾಗಿರುವ ನೀನು

53
00:03:09,000 --> 00:03:14,000
ಮತ್ತು ನಾವು 2 ಸರಿಹೊಂದುವ ಶಕ್ತಿಯಿಂದ ಪ್ರತಿ ಅಂಕಿಯ ಗುಣಿಸಿದಾಗ ಮಾಡುತ್ತಿದ್ದೇವೆ.

54
00:03:14,000 --> 00:03:19,000
ಮತ್ತು, ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ನಾವು ಆರಂಭದಲ್ಲಿ 0x ಈ ಸಂಖ್ಯೆಗಳನ್ನು ಸೂಚಿಸಲು

55
00:03:19,000 --> 00:03:23,000
ಆದ್ದರಿಂದ ನಾವು ದಶಮಾಂಶ ಸಂಖ್ಯೆಯ ಗೊಂದಲ ಇಲ್ಲ.

56
00:03:23,000 --> 00:03:29,000
ಮುಂದುವರೆಯುತ್ತಿದೆ, ಈ, ಒಂದು ASCII ಟೇಬಲ್ ಆಗಿದೆ

57
00:03:29,000 --> 00:03:35,000
ಮತ್ತು ನಾವು ASCII ಬಳಸುವುದಕ್ಕೆ ಪಾತ್ರಗಳಾದ ಸಂಖ್ಯಾತ್ಮಕ ಮೌಲ್ಯಗಳನ್ನು ಗೆ ಮ್ಯಾಪ್ ಆಗಿದೆ.

58
00:03:35,000 --> 00:03:39,000
ಗೂಢಲಿಪಿಶಾಸ್ತ್ರ pset ರಲ್ಲಿ ನೆನಪಿಡಿ ನಾವು ASCII ಟೇಬಲ್ ವ್ಯಾಪಕವಾದ ಬಳಕೆಯನ್ನು ಮಾಡಿದ

59
00:03:39,000 --> 00:03:43,000
ಗೂಢಲಿಪಿಶಾಸ್ತ್ರ ವಿವಿಧ ವಿಧಾನಗಳನ್ನು ಬಳಸಲು,

60
00:03:43,000 --> 00:03:47,000
ವಿವಿಧ ಅಕ್ಷರಗಳನ್ನು ಪರಿವರ್ತಿಸಲು ಸೀಸರ್ ಮತ್ತು Vigenère ಸೈಫರ್,

61
00:03:47,000 --> 00:03:52,000
ಬಳಕೆದಾರ ನೀಡಿದ ಕೀಲಿಯನ್ನು ಪ್ರಕಾರ ಒಂದು ಸಾಲಿನಲ್ಲಿ.

62
00:03:52,000 --> 00:03:56,000
ನ ASCII ಗಣಿತ ಒಂದು ಸ್ವಲ್ಪ ನೋಡೋಣ.

63
00:03:56,000 --> 00:04:02,000
ಪ್ರಶ್ನೆ ಎಂದು ಅಕ್ಷರ ರೂಪದಲ್ಲಿ, 'ಪಿ' ನಲ್ಲಿ + 1 ನೋಡುತ್ತಿರುವುದು,

64
00:04:02,000 --> 00:04:07,000
ಮತ್ತು '5 '≠ 5 ನೆನಪಿನಲ್ಲಿಡಿ.

65
00:04:07,000 --> 00:04:10,000
ಮತ್ತು ಹೇಗೆ ನಿಖರವಾಗಿ ನಾವು ಆ 2 ನಡುವಿನ ಪರಿವರ್ತಿಸಲು ಎಂದು?

66
00:04:10,000 --> 00:04:13,000
ಇದು ನಿಜವಾಗಿಯೂ ತುಂಬಾ ಹಾರ್ಡ್ ಅಲ್ಲ.

67
00:04:13,000 --> 00:04:16,000
5 ಪಡೆಯುವ ಸಲುವಾಗಿ ನಾವು '0 ಕಳೆಯಿರಿ '

68
00:04:16,000 --> 00:04:20,000
ಏಕೆಂದರೆ '0 ನಡುವೆ 5 ಸ್ಥಳಗಳಲ್ಲಿ 'ಮತ್ತು '5.'

69
00:04:20,000 --> 00:04:23,000
ನಾವು 0 ಸೇರಿಸಿ ಇತರ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ ಸಲುವಾಗಿ,

70
00:04:23,000 --> 00:04:25,000
ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ ಗಣಿತ ಮುಂತಾದ ರೀತಿಯ ಇಲ್ಲಿದೆ.

71
00:04:25,000 --> 00:04:29,000
ಕೇವಲ ಏನೋ ಇದು ಸುಮಾರು ಉಲ್ಲೇಖಗಳು ಯಾವಾಗ ಒಂದು ಪಾತ್ರದ ನೆನಪು

72
00:04:29,000 --> 00:04:37,000
ಆದ್ದರಿಂದ ASCII ಕೋಷ್ಟಕದಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

73
00:04:37,000 --> 00:04:40,000
ಸಾಮಾನ್ಯ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನ ವಿಷಯಗಳನ್ನು ಚಲಿಸಿದ.

74
00:04:40,000 --> 00:04:43,000
ನಾವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಸುವುದಕ್ಕೆ ಒಂದು ಕ್ರಮಾವಳಿ ಮತ್ತು ಕಲಿತರು

75
00:04:43,000 --> 00:04:45,000
ಕ್ರಮಾವಳಿಗಳನ್ನು ಅಳವಡಿಸಲು.

76
00:04:45,000 --> 00:04:48,000
ಕ್ರಮಾವಳಿಗಳು ಕೆಲವು ಉದಾಹರಣೆಗಳು ನಂತಹ ನಿಜವಾಗಿಯೂ ಸರಳ ಏನೋ

77
00:04:48,000 --> 00:04:51,000
ಒಂದು ಸಂಖ್ಯೆ ಸಮ ಅಥವಾ ಬೆಸ ಎಂದು ಪರೀಕ್ಷಿಸುವುದು.

78
00:04:51,000 --> 00:04:54,000
ಇದಕ್ಕಾಗಿ ನಾವು 2 ಸಂಖ್ಯೆಯ Mod ಮತ್ತು ಪರಿಣಾಮವಾಗಿ 0 ವೇಳೆ ಪರೀಕ್ಷಿಸಲು ಮರೆಯದಿರಿ.

79
00:04:54,000 --> 00:04:57,000
ಹಾಗಿದ್ದಲ್ಲಿ, ಇದು ಕೂಡ ಇಲ್ಲಿದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಇದು ಬೆಸ ಇಲ್ಲಿದೆ.

80
00:04:57,000 --> 00:04:59,000
ಮತ್ತು ಒಂದು ನಿಜವಾಗಿಯೂ ಮೂಲ ಕ್ರಮಾವಳಿ ಒಂದು ಉದಾಹರಣೆ.

81
00:04:59,000 --> 00:05:02,000
>> ಹೆಚ್ಚು ಒಳಗೊಂಡಿರುವ ಒಂದು ಸ್ವಲ್ಪ ಬೈನರಿ ಸರ್ಚ್ ಹೊಂದಿದೆ,

82
00:05:02,000 --> 00:05:05,000
ಇದು ನಾವು ವಿಮರ್ಶೆ ಅಧಿವೇಶನದ ನಂತರ ಮೇಲೆ ಹೋಗಿ ನೋಡುತ್ತಾರೆ.

83
00:05:05,000 --> 00:05:09,000
ಮತ್ತು ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ನಾವು ಒಂದು ಕ್ರಮಾವಳಿ ತೆಗೆದುಕೊಳ್ಳುವ ಬಳಸಲು ಪದ

84
00:05:09,000 --> 00:05:15,000
ಮತ್ತು ಕಂಪ್ಯೂಟರ್ ಕೋಡ್ ಬದಲಾಯಿಸಲಾಗಿಲ್ಲ ಓದಬಹುದು.

85
00:05:15,000 --> 00:05:20,000
ಕಾರ್ಯಕ್ರಮಗಳ 2 ಉದಾಹರಣೆಗಳು, ಸ್ಕ್ರಾಚ್ ಆಗಿದೆ

86
00:05:20,000 --> 00:05:22,000
ಇದು ನಾವು ವೀಕ್ 0 ರಲ್ಲಿ ಏನು ಆಗಿದೆ.

87
00:05:22,000 --> 00:05:25,000
ನಾವು ವಾಸ್ತವವಾಗಿ ಕೋಡ್ ಔಟ್ ಟೈಪ್ ಸಹ ಆದರೂ ಇದು ಅನುಷ್ಠಾನಕ್ಕೆ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ

88
00:05:25,000 --> 00:05:29,000
ಸಂಖ್ಯೆಗಳನ್ನು 1-10 ಮುದ್ರಿಸುವ ಇದು ಈ ಕ್ರಮಾವಳಿ,

89
00:05:29,000 --> 00:05:32,000
ಮತ್ತು ಇಲ್ಲಿ ನಾವು C ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಹೀಗೆ.

90
00:05:32,000 --> 00:05:41,000
ಈ ಕೇವಲ ವಿವಿಧ ಭಾಷೆಗಳಲ್ಲಿ ಅಥವಾ ವಾಕ್ಯ ಬರೆದ ಕಾರ್ಯಕಾರಿಯಾಗಿ ಸಮನಾಗಿದೆ.

91
00:05:41,000 --> 00:05:44,000
ನಾವು ಆಗ, ಬೂಲಿಯನ್ ನಿರೂಪಣೆಗಳೂ ಕಲಿತ

92
00:05:44,000 --> 00:05:48,000
ಮತ್ತು ಒಂದು ಬೂಲಿಯನ್, ಸರಿ ಅಥವಾ ತಪ್ಪು ಎರಡೂ ಎಂದು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ

93
00:05:48,000 --> 00:05:51,000
ಇಲ್ಲಿ ಅನೇಕ ವೇಳೆ ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳು

94
00:05:51,000 --> 00:05:55,000
ಆದ್ದರಿಂದ (x ≤ 5), ಪರಿಸ್ಥಿತಿಗಳ ಒಳಗೆ ಹೋಗಿ,

95
00:05:55,000 --> 00:06:00,000
ಹಾಗೆಯೇ, ನಾವು ಈಗಾಗಲೇ ಷರತ್ತಿನ ನಿಜವಾದ ಗೆ ಮೌಲ್ಯಮಾಪನ ಹೋಗುವ ಇದೆ X = 5, ಆದ್ದರಿಂದ ಸೆಟ್.

96
00:06:00,000 --> 00:06:03,000
ಇದು ನಿಜ ವೇಳೆ ಮತ್ತು, ಯಾವುದೇ ಕೋಡ್ ಸ್ಥಿತಿಯನ್ನು ಕೆಳಗಡೆ

97
00:06:03,000 --> 00:06:08,000
ಕಂಪ್ಯೂಟರ್ ಮೌಲ್ಯಮಾಪನ ಹೋಗುವ ಇದೆ, ಆದ್ದರಿಂದ ಸ್ಟ್ರಿಂಗ್ ಮುದ್ರಿತ ಏರಲಿದೆ

98
00:06:08,000 --> 00:06:12,000
ಗುಣಮಟ್ಟದ ಉತ್ಪಾದನೆ, ಮತ್ತು ಪದ ಸ್ಥಿತಿಗೆ

99
00:06:12,000 --> 00:06:16,000
ವೇಳೆ ಹೇಳಿಕೆಯ ಆವರಣ ಒಳಗೆ ಯಾವುದೇ ಸೂಚಿಸುತ್ತದೆ.

100
00:06:16,000 --> 00:06:20,000
ಎಲ್ಲಾ ನಿರ್ವಾಹಕರು ನೆನಪಿಡಿ.

101
00:06:20,000 --> 00:06:26,000
| ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಸಂದರ್ಭದಲ್ಲಿ ಸಂಯೋಜಿಸಲು 2 ಅಥವಾ ಹೆಚ್ಚಿನ ಪರಿಸ್ಥಿತಿಗಳು, | ಅದನ್ನು && ಮತ್ತು ನೆನಪಿಡಿ

102
00:06:26,000 --> 00:06:30,000
== ಅಲ್ಲ = 2 ಸಂಗತಿಗಳು ಸಮಾನವಾಗಿವೆ ಎಂದು ಪರಿಶೀಲಿಸಲು.

103
00:06:30,000 --> 00:06:36,000
== ಒಂದು ಬೂಲಿಯನ್ ಆಯೋಜಕರು ಆದರೆ = ನಿಯೋಜನೆ ಫಾರ್ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

104
00:06:36,000 --> 00:06:41,000
≤, ≥ ಮತ್ತು ನಂತರ ಅಂತಿಮ 2 ಸ್ವಯಂ ವಿವರಣಾತ್ಮಕ ಇವೆ.

105
00:06:41,000 --> 00:06:45,000
ಇಲ್ಲಿ ಬೂಲಿಯನ್ ತರ್ಕವನ್ನು ಒಂದು ಸಾಮಾನ್ಯ ವಿಮರ್ಶೆ.

106
00:06:45,000 --> 00:06:48,000
ಮತ್ತು ಬೂಲಿಯನ್ ಅಭಿವ್ಯಕ್ತಿಗಳು, ಲೂಪ್ ಕೂಡ ಮುಖ್ಯ

107
00:06:48,000 --> 00:06:50,000
ಇದು ನಾವು ಈಗ ಮೇಲೆ ಹೋಗುತ್ತೇನೆ.

108
00:06:50,000 --> 00:06:56,000
ನಾವು ಆದರೆ, ಫಾರ್, CS50 ಇಲ್ಲಿಯವರೆಗೆ ಕುಣಿಕೆಗಳು ಸುಮಾರು 3 ರೀತಿಯ ಕಲಿತರು, ಮತ್ತು ಹಾಗೆಯೇ ಮಾಡಬೇಕು.

109
00:06:56,000 --> 00:06:59,000
ಮತ್ತು ಅದನ್ನು ತಿಳಿಯಲು ಪ್ರಮುಖ ಹೆಚ್ಚಿನ ಉದ್ದೇಶಗಳಿಗಾಗಿ ಸಂದರ್ಭದಲ್ಲಿ

110
00:06:59,000 --> 00:07:02,000
ನಾವು ವಾಸ್ತವವಾಗಿ ಸಾಮಾನ್ಯವಾಗಿ ಲೂಪ್ ಯಾವುದೇ ರೀತಿಯ ಬಳಸಬಹುದು

111
00:07:02,000 --> 00:07:06,000
ಉದ್ದೇಶಗಳಿಗಾಗಿ ಅಥವಾ ಸಾಮಾನ್ಯ ಮಾದರಿಗಳ ಕೆಲವು ರೀತಿಯ

112
00:07:06,000 --> 00:07:09,000
ನಿರ್ದಿಷ್ಟವಾಗಿ ಈ ಕುಣಿಕೆಗಳನ್ನು ಒಂದು ಕರೆ ಎಂದು ಪ್ರೊಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ

113
00:07:09,000 --> 00:07:13,000
ಇದನ್ನು ಮಾಡಲು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿಯಾದ ಅಥವಾ ಆ ರೀತಿಯಲ್ಲಿ ಇದು ಕೋಡ್ ಗೆ ಸೊಗಸಾದ.

114
00:07:13,000 --> 00:07:18,000
ನ ಈ ಕುಣಿಕೆಗಳು ಪ್ರತಿಯೊಂದು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಒಲವು ಯಾವ ಮೇಲೆ ಹೋಗಿ ನೋಡೋಣ.

115
00:07:18,000 --> 00:07:21,000
>> ಒಂದು ಲೂಪ್ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಈಗಾಗಲೇ ನಾವು ಮರಳಿ ಬಯಸುವ ಎಷ್ಟು ಬಾರಿ ತಿಳಿದಿದೆ.

116
00:07:21,000 --> 00:07:24,000
ನಾವು ಸ್ಥಿತಿಯಲ್ಲಿ ಪುಟ್ ಇಲ್ಲಿದೆ.

117
00:07:24,000 --> 00:07:28,000
ನಾನು = 0, ನಾನು <10, ಉದಾಹರಣೆಗೆ.

118
00:07:28,000 --> 00:07:31,000
ನಾವು ಈಗಾಗಲೇ ಏನೋ 10 ಬಾರಿ ಮಾಡಲು ಬಯಸುವ ತಿಳಿದಿದೆ.

119
00:07:31,000 --> 00:07:34,000
ಈಗ, ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಫಾರ್, ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ಎಂದೇನೂ ಇಲ್ಲ

120
00:07:34,000 --> 00:07:36,000
ನಾವು ಲೂಪ್ ಚಲಾಯಿಸಲು ಬಯಸುವ ಎಷ್ಟು ಬಾರಿ ತಿಳಿದಿದೆ.

121
00:07:36,000 --> 00:07:39,000
ಆದರೆ ನಾವು ಬಯಸುವ ಪರಿಸ್ಥಿತಿ ಕೆಲವು ರೀತಿಯ ಗೊತ್ತು

122
00:07:39,000 --> 00:07:41,000
ಯಾವಾಗಲೂ ನೈಜ ಅಥವಾ ಯಾವಾಗಲೂ ಸುಳ್ಳು.

123
00:07:41,000 --> 00:07:44,000
ಉದಾಹರಣೆಗೆ, ಆದರೆ ಹೊಂದಿಸಲಾಗಿದೆ.

124
00:07:44,000 --> 00:07:46,000
ಲೆಟ್ಸ್ ಒಂದು ಬೂಲಿಯನ್ ವೇರಿಯಬಲ್ ಎಂದು ಹೇಳುತ್ತಾರೆ.

125
00:07:46,000 --> 00:07:48,000
ನಿಜವಾದ ವಿಷಯವೆಂದರೆ ನಾವು ಕೋಡ್ ಮೌಲ್ಯಮಾಪನ ಬಯಸುವ,

126
00:07:48,000 --> 00:07:52,000
ಆದ್ದರಿಂದ ಸ್ವಲ್ಪ ವಿಸ್ತರಣೆಯು, ಲೂಪ್ ಒಂದು ಹೆಚ್ಚು ಸಾಮಾನ್ಯ ಸ್ವಲ್ಪ,

127
00:07:52,000 --> 00:07:55,000
ಆದರೆ ಲೂಪ್ ಯಾವುದೇ ಒಂದು ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಪರಿವರ್ತಿಸಬಹುದು.

128
00:07:55,000 --> 00:08:00,000
ಅಂತಿಮವಾಗಿ, ಹಾಗೆ ಮಾಡುವಾಗ ಈಗಿನಿಂದಲೇ ಗ್ರಹಿಸಲು trickiest ಆಗಿರಬಹುದು ಕುಣಿಕೆಗಳು,

129
00:08:00,000 --> 00:08:04,000
ನಾವು ಮೊದಲ ಕೋಡ್ ಮೌಲ್ಯಮಾಪನ ಬಯಸುವ ಕೆಲವೊಮ್ಮೆ ಬಳಸಲಾಗುತ್ತದೆ

130
00:08:04,000 --> 00:08:06,000
ಮೊದಲ ಬಾರಿಗೆ ಮೊದಲು ನಾವು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಿ.

131
00:08:06,000 --> 00:08:09,000
ಒಂದು ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ ಲೂಪ್

132
00:08:09,000 --> 00:08:12,000
ನೀವು ಬಳಕೆದಾರ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಬಯಸಿದಾಗ, ಮತ್ತು ನೀವು ಬಳಕೆದಾರ ಕೇಳಲು ಬಯಸುವ ತಿಳಿದಿದೆ

133
00:08:12,000 --> 00:08:15,000
ಸೇರಿಸುವ ಒಮ್ಮೆಲೇ, ಆದರೆ ನೀವು ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನೀಡದಿದ್ದಲ್ಲಿ ಈಗಿನಿಂದಲೇ

134
00:08:15,000 --> 00:08:18,000
ಅವರು ನೀವು ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನೀಡುವ ತನಕ ಕೇಳಿ ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತೀರಿ.

135
00:08:18,000 --> 00:08:21,000
ಆದರೆ ಲೂಪ್ ಒಂದು ಸಾಮಾನ್ಯ ಬಳಕೆಯ ಆ ಬೇಕು

136
00:08:21,000 --> 00:08:23,000
ಮತ್ತು ಅವರ ಈ ಕುಣಿಕೆಗಳು ನಿಜವಾದ ರಚನೆಯನ್ನು ನೋಡೋಣ.

137
00:08:23,000 --> 00:08:27,000
ಅವರು ಸಾಮಾನ್ಯವಾಗಿ ಯಾವಾಗಲೂ ಈ ಮಾದರಿಗಳನ್ನು ಒಲವು.

138
00:08:27,000 --> 00:08:30,000
>> ಒಳಗಿನ ಲೂಪ್ ನಲ್ಲಿ 3 ಘಟಕಗಳನ್ನು ಹೊಂದಿವೆ:

139
00:08:30,000 --> 00:08:35,000
ಪ್ರಾಥಮಿಕ, ವಿಶಿಷ್ಟವಾಗಿ ಏನಾದರೂ ನಂತಹ ಇಂಟ್ ನಾನು ಕೌಂಟರ್ ಅಲ್ಲಿ = 0,

140
00:08:35,000 --> 00:08:40,000
ಈ ಪರಿಸ್ಥಿತಿ ಇನ್ನೂ ಹೊಂದಿದೆ ತನಕ ಲೂಪ್ ಈ ರನ್ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ ಅಲ್ಲಿ ಪರಿಸ್ಥಿತಿ,,

141
00:08:40,000 --> 00:08:44,000
ನಾವು ಹೆಚ್ಚಿಸಲು ಹೇಗೆ ಇದು ನಾನು ಅಂತಿಮವಾಗಿ ನಂತರ <10, ಮತ್ತು, ಅಪ್ಡೇಟ್, ಹಾಗೆ

142
00:08:44,000 --> 00:08:47,000
ಚಕ್ರಕ್ಕೆ ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಪ್ರತಿ ವೇರಿಯಬಲ್.

143
00:08:47,000 --> 00:08:50,000
ಅಲ್ಲಿ ನೋಡಲು ಒಂದು ಸಾಮಾನ್ಯ ವಿಷಯವಾಗಿ, ನಾನು + + ಆಗಿದೆ

144
00:08:50,000 --> 00:08:52,000
ಇದು 1 ರಿಂದ ಪ್ರತಿ ಬಾರಿ ನಾನು ಹೆಚ್ಚಿಸಲು ಅರ್ಥ.

145
00:08:52,000 --> 00:08:55,000
ನೀವು, ನಾನು + = 2 ರೀತಿಯ ಇಲ್ಲ

146
00:08:55,000 --> 00:08:58,000
ಇದು ನಾನು ನೀವು ಲೂಪ್ ಮೂಲಕ ಹೋಗಿ ಪ್ರತಿ ಬಾರಿ 2 ಸೇರಿಸಲು ಅರ್ಥ.

147
00:08:58,000 --> 00:09:03,000
ನಂತರ ಇದನ್ನು ಕೇವಲ ವಾಸ್ತವವಾಗಿ ಲೂಪ್ ಭಾಗವಾಗಿ ಹರಿಯುತ್ತದೆ ಯಾವುದೇ ಕೋಡ್ ಸೂಚಿಸುತ್ತದೆ.

148
00:09:03,000 --> 00:09:09,000
ಮತ್ತು ಸ್ವಲ್ಪ ಲೂಪ್, ಈ ಬಾರಿ ನಾವು ವಾಸ್ತವವಾಗಿ, ಲೂಪ್ ಹೊರಗೆ ಆರಂಭಕ್ಕೆ ಹೊಂದಿವೆ

149
00:09:09,000 --> 00:09:12,000
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾವು ನಾನು ವಿವರಿಸಿದಂತೆ ಲೂಪ್ ಅದೇ ರೀತಿಯ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಹೇಳಲು ಅವಕಾಶ.

150
00:09:12,000 --> 00:09:16,000
ನಾವು ಇಂಟ್ ನಾನು = 0 ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುವುದಕ್ಕೆ ಮೊದಲು ಹೇಳುತ್ತಿದ್ದರು.

151
00:09:16,000 --> 00:09:20,000
ನಾನು <10 ಹಾಗೆ ಆದರೆ ನಂತರ ನಾವು ಹೇಳಬಹುದು

152
00:09:20,000 --> 00:09:22,000
ಮೊದಲು ಕೋಡ್ ಆದ್ದರಿಂದ ಅದೇ ಬ್ಲಾಕ್,

153
00:09:22,000 --> 00:09:26,000
ಈ ಸಮಯದಲ್ಲಿ ಉದಾಹರಣೆಗೆ ಕೋಡ್ ಅಪ್ಡೇಟ್ ಭಾಗವಾಗಿ, ನಾನು + +

154
00:09:26,000 --> 00:09:29,000
ವಾಸ್ತವವಾಗಿ ಲೂಪ್ ಒಳಗೆ ಹೋಗುತ್ತದೆ.

155
00:09:29,000 --> 00:09:33,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಒಂದು, ಅದು ಹಾಗೆಯೇ ಲೂಪ್ನಂತೆಯೇ ವಿಷಯವೆಂದರೆ ಹಾಗೆ,

156
00:09:33,000 --> 00:09:36,000
ಆದರೆ ಕೋಡ್ ಒಮ್ಮೆ ಮೌಲ್ಯಮಾಪನ ಎಂದು ನೆನಪಿಡುವ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ

157
00:09:36,000 --> 00:09:40,000
ಪರಿಸ್ಥಿತಿ ಪರಿಶೀಲಿಸಿದ ಮೊದಲು, ಆದ್ದರಿಂದ ಬಹಳ ಸಮಂಜಸವಾಗಿರುತ್ತದೆ

158
00:09:40,000 --> 00:09:44,000
ನೀವು ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಮೇರೆಗೆ ಅದನ್ನು ನೋಡಲು. ವೇಳೆ

159
00:09:44,000 --> 00:09:49,000
ಒಂದು ನೀವು ಕೂಡ ಅದೇ ಸ್ಥಿತಿಯನ್ನು ನೋಡಲು ಮೊದಲು ಲೂಪ್ ಕೋಡ್ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವಾಗ ಹಾಗೆ,

160
00:09:49,000 --> 00:09:55,000
ಸ್ವಲ್ಪ ಲೂಪ್ ಆದರೆ, ಇದು ಮೊದಲ ಪರಿಶೀಲಿಸುತ್ತದೆ.

161
00:09:55,000 --> 00:09:59,000
ಹೇಳಿಕೆಗಳು ಮತ್ತು ಅಸ್ಥಿರ.

162
00:09:59,000 --> 00:10:04,000
ನಾವು ಹೊಸ ವೇರಿಯಬಲ್ ರಚಿಸಲು ಬಯಸುವ ನಾವು ಮೊದಲು ಆರಂಭಿಸಲು ಬಯಸುವ.

163
00:10:04,000 --> 00:10:07,000
>> ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಬಾರ್, ವೇರಿಯಬಲ್ ಬಾರ್ ಆರಂಭಿಸುತ್ತದೆ

164
00:10:07,000 --> 00:10:10,000
ಆದರೆ ಈಗ ಬಾರ್ ಮೌಲ್ಯದ ಏನು ಅದು ಮೌಲ್ಯವನ್ನು ನೀಡುವುದಿಲ್ಲ?

165
00:10:10,000 --> 00:10:12,000
ನಾವು ಗೊತ್ತಿಲ್ಲ.

166
00:10:12,000 --> 00:10:14,000
ಇದು ಹಿಂದೆ ಅಲ್ಲಿ ಮೆಮೊರಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಕೆಲವು ತ್ಯಾಜ್ಯವನ್ನು ಮೌಲ್ಯವನ್ನು ಆಗಿರಬಹುದು

167
00:10:14,000 --> 00:10:16,000
ಮತ್ತು ನಾವು ವೇರಿಯಬಲ್ ಬಳಸಲು ಇಷ್ಟವಿಲ್ಲ

168
00:10:16,000 --> 00:10:19,000
ನಾವು ವಾಸ್ತವವಾಗಿ ಇದು ಒಂದು ಮೌಲ್ಯವನ್ನು ನೀಡಿ ರವರೆಗೆ

169
00:10:19,000 --> 00:10:21,000
ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಘೋಷಿಸಬೇಕಾಗಿದೆ.

170
00:10:21,000 --> 00:10:24,000
ನಂತರ ನಾವು ಕೆಳಗೆ 42 ಎಂದು ಆರಂಭಿಸಲು.

171
00:10:24,000 --> 00:10:28,000
ಈಗ, ನಾವು ಈ ಒಂದು ಸಾಲಿನಲ್ಲಿ, ಇಂಟ್ ಬಾರ್ = 42 ಮಾಡಬಹುದು ತಿಳಿದಿದೆ.

172
00:10:28,000 --> 00:10:30,000
ಆದರೆ, ಹೋಗುಗಳನ್ನು ಅನೇಕ ಹಂತಗಳನ್ನು ತೆರವುಗೊಳಿಸಿ ಎಂದು

173
00:10:30,000 --> 00:10:34,000
ಘೋಷಣೆ ಮತ್ತು ಆರಂಭಕ್ಕೆ ಇಲ್ಲಿ ಪ್ರತ್ಯೇಕವಾಗಿ ಸಂಭವಿಸುತ್ತಿವೆ.

174
00:10:34,000 --> 00:10:38,000
ಮುಂದಿನ ಒಂದು, ಇಂಟ್ ಬಾಜ್ = ಬಾರ್ + 1, ಒಂದು ಹಂತದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ, ಮತ್ತು

175
00:10:38,000 --> 00:10:44,000
ಈ ಕೋಡ್ ಬ್ಲಾಕ್ ಕೊನೆಯಲ್ಲಿ ಕೆಳಗೆ ಈ ಹೇಳಿಕೆ, ಆ ಬೆಳವಣಿಗೆಗಳ ಬಾಜ್,

176
00:10:44,000 --> 00:10:48,000
ನಾವು ಬಾಜ್ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸಲು ಬಳಸಿದರೆ 44 ಎಂದು

177
00:10:48,000 --> 00:10:52,000
ನಾವು, ಘೋಷಿಸಲು ಮತ್ತು 1> ಬಾರ್ ಎಂದು ಇದು ಆರಂಭಿಸಲು ಕಾರಣ

178
00:10:52,000 --> 00:10:58,000
ನಂತರ ನಾವು ಮತ್ತೆ ಅದನ್ನು ಹೆಚ್ಚಿಸಲು + +.

179
00:10:58,000 --> 00:11:02,000
ಈ ಬಹಳ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮೇಲೆ ಹೋದರು, ಆದರೆ ಇದು ಒಂದು ಸಾಮಾನ್ಯ ಹೊಂದುವುದು ಒಳ್ಳೆಯದು

180
00:11:02,000 --> 00:11:04,000
ಎಳೆಗಳನ್ನು ಮತ್ತು ಘಟನೆಗಳು ಎಂಬುದನ್ನು ಅರ್ಥ ಮಾಡಿಕೊಳ್ಳಲು.

181
00:11:04,000 --> 00:11:06,000
ನಾವು ಮುಖ್ಯವಾಗಿ, ಸ್ಕ್ರ್ಯಾಚ್ ಈ ಮಾಡಿದರು

182
00:11:06,000 --> 00:11:09,000
ಆದ್ದರಿಂದ ನೀವು ಕೋಡ್ ಬಹು ಸೀಕ್ವೆನ್ಸ್ ಎಳೆಗಳನ್ನು ನಗರದ

183
00:11:09,000 --> 00:11:11,000
ಅದೇ ಸಮಯದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ.

184
00:11:11,000 --> 00:11:14,000
ವಾಸ್ತವದಲ್ಲಿ, ಇದು ಬಹುಶಃ ಅದೇ ಸಮಯದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿಲ್ಲ

185
00:11:14,000 --> 00:11:17,000
ಆದರೆ ರೀತಿಯ ಅಮೂರ್ತವಾದ ಆ ರೀತಿಯಲ್ಲಿ ಇದು ನಗರದ.

186
00:11:17,000 --> 00:11:20,000
>> ಸ್ಕ್ರಾಚ್ ಉದಾಹರಣೆಗೆ, ನಾವು ಅನೇಕ sprites ಹೊಂದಿತ್ತು.

187
00:11:20,000 --> 00:11:22,000
ಅದೇ ಸಮಯದಲ್ಲಿ ವಿಭಿನ್ನ ಕೋಡ್ ಪಾಲಿಸಲು ಸಾಧ್ಯ.

188
00:11:22,000 --> 00:11:26,000
ಇತರ ಹೇಳುತ್ತಿದ್ದೇನೆ ಆದರೆ ಒಂದು ವಾಕಿಂಗ್ ಮಾಡಬಹುದು

189
00:11:26,000 --> 00:11:29,000
ಪರದೆಯ ಬೇರೆ ಭಾಗದಲ್ಲಿ.

190
00:11:29,000 --> 00:11:34,000
ಕ್ರಿಯೆಗಳು ತರ್ಕ ಬೇರ್ಪಡಿಸುವ ಇನ್ನೊಂದು ದಾರಿ

191
00:11:34,000 --> 00:11:37,000
ನಿಮ್ಮ ಕೋಡ್ ವಿವಿಧ ಅಂಶಗಳ ನಡುವೆ,

192
00:11:37,000 --> 00:11:40,000
ಮತ್ತು ಸ್ಕ್ರ್ಯಾಚ್ ನಾವು, ಬ್ರಾಡ್ಕಾಸ್ಟ್ ಅನ್ನು ಘಟನೆಗಳು ಅನುಕರಿಸಲು ಸಮರ್ಥರಾದರು

193
00:11:40,000 --> 00:11:43,000
ನಾನು ಸ್ವೀಕರಿಸಿದಾಗ ಮತ್ತು, ನಾನು ಹಿಯರ್ ಇದ್ದಾಗ, ವಾಸ್ತವವಾಗಿ

194
00:11:43,000 --> 00:11:47,000
ಆದರೆ ಮೂಲಭೂತವಾಗಿ ಈ ಮಾಹಿತಿಯನ್ನು ರವಾನಿಸಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ

195
00:11:47,000 --> 00:11:49,000
ಒಂದು ಸ್ಪ್ರೈಟ್ ಇನ್ನೊಂದು.

196
00:11:49,000 --> 00:11:52,000
ಉದಾಹರಣೆಗೆ, ನೀವು, ಆಟದ ಮೇಲೆ ಪ್ರಸಾರ ಬಯಸಬಹುದು

197
00:11:52,000 --> 00:11:56,000
ಮತ್ತೊಂದು ಪಿಶಾಚಿ ಆಟ ಸ್ವೀಕರಿಸಿದಾಗ,

198
00:11:56,000 --> 00:11:58,000
ಇದು ಕೆಲವು ರೀತಿಯಲ್ಲಿ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ.

199
00:11:58,000 --> 00:12:03,000
ಇದು ಕಾರ್ಯಕ್ರಮಗಳ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಒಂದು ಪ್ರಮುಖ ಮಾದರಿ.

200
00:12:03,000 --> 00:12:07,000
ಕೇವಲ ಮೂಲ ವೀಕ್ 0 ಮೇಲೆ ಹೋಗಿ, ನಾವು ಇದುವರೆಗೆ ಸುಮಾರು ಹೋಗಿದ್ದೀರಿ,

201
00:12:07,000 --> 00:12:10,000
ಅವರ ಈ ಸರಳ ಸಿ ಪ್ರೋಗ್ರಾಂ ನೋಡೋಣ.

202
00:12:10,000 --> 00:12:14,000
ಪಠ್ಯ ಇಲ್ಲಿಂದ ಸಣ್ಣ ಸ್ವಲ್ಪ, ಆದರೆ ನಾನು ಅದನ್ನು ನಿಜವಾಗಿಯೂ ತ್ವರಿತ ಹೋಗುತ್ತೇನೆ.

203
00:12:14,000 --> 00:12:20,000
ನಾವು ಉನ್ನತ, cs50.h ಮತ್ತು stdio.h 2 ಹೆಡರ್ ಕಡತಗಳನ್ನು ಸೇರಿದಂತೆ ನೀವು.

204
00:12:20,000 --> 00:12:23,000
ನಾವು 100 ಎಂದು ನಿರಂತರ ಎಂಬ ಮಿತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡುತ್ತಿದ್ದೇವೆ.

205
00:12:23,000 --> 00:12:26,000
ನಾವು ನಮ್ಮ ಮುಖ್ಯ ಕಾರ್ಯವನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

206
00:12:26,000 --> 00:12:29,000
ನಾವು ಇಲ್ಲಿ ಆಜ್ಞಾ ಸಾಲಿನ ಆರ್ಗುಮೆಂಟ್ಗಳನ್ನು ಬಳಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ನಾವು ಶೂನ್ಯವನ್ನು ಇರಿಸಬೇಕಾಗುತ್ತದೆ

207
00:12:29,000 --> 00:12:32,000
ಮುಖ್ಯ ಫಾರ್ ವಾದಗಳನ್ನು.

208
00:12:32,000 --> 00:12:38,000
ನಾವು ಪ್ರಮುಖ ಮೇಲೆ ಇಂಟ್ ನೋಡಿ. ರಿಟರ್ನ್ ಪ್ರಕಾರದ ಎಂದು, ಆದ್ದರಿಂದ ಕೆಳಭಾಗದಲ್ಲಿ 0 ಹಿಂತಿರುಗಿ.

209
00:12:38,000 --> 00:12:41,000
ಮತ್ತು ನಾವು ಇಂಟ್ ಪಡೆಯಲು CS50 ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ ಬಳಸುತ್ತಿದ್ದೀರಿ

210
00:12:41,000 --> 00:12:45,000
ಇನ್ಪುಟ್ ಬಳಕೆದಾರ ಕೇಳಬಹುದು, ಮತ್ತು ನಾವು ಈ ವ್ಯತ್ಯಯ X ಅದನ್ನು ಸಂಗ್ರಹಿಸಲು,

211
00:12:45,000 --> 00:12:51,000
ಆದ್ದರಿಂದ ನಾವು ಮೇಲೆ X ಘೋಷಿಸಿದ, ಮತ್ತು x = GetInt ಇದನ್ನು ಆರಂಭಿಸಲು.

212
00:12:51,000 --> 00:12:53,000
>> ನಾವು ನಂತರ ಬಳಕೆದಾರ ನಮಗೆ ಒಳ್ಳೆಯ ಇನ್ಪುಟ್ ನೀಡಿದರು ನೀವು ಪರೀಕ್ಷಿಸಿ.

213
00:12:53,000 --> 00:12:59,000
ಇದು ≥ LIMIT ಆಗಿದ್ದರೆ ನಾವು 1 ಒಂದು ದೋಷ ಕೋಡ್ ಹಿಂದಿರುಗಿ ಒಂದು ದೋಷ ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸಲು ಬಯಸುವ.

214
00:12:59,000 --> 00:13:02,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಬಳಕೆದಾರ ನಮಗೆ ನೀಡಿದ ವೇಳೆ ಒಳ್ಳೆಯ ಇನ್ಪುಟ್

215
00:13:02,000 --> 00:13:08,000
ನಾವು ಸಂಖ್ಯೆ ಸ್ಕ್ವೇರ್ ಮತ್ತು ಪರಿಣಾಮವಾಗಿ ಮುದ್ರಿಸುತ್ತದೆ ಎಂದು ನೀನು.

216
00:13:08,000 --> 00:13:11,000
ಕೇವಲ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಆ ಹಿಟ್ ಮನೆಯ ಎಲ್ಲಾ

217
00:13:11,000 --> 00:13:17,000
ನೀವು ಇಲ್ಲಿ ಕೋಡ್ ವಿವಿಧ ಭಾಗಗಳ ಲೇಬಲ್ಗಳನ್ನು ನೋಡಬಹುದು.

218
00:13:17,000 --> 00:13:19,000
ನಾನು ಸ್ಥಿರ, ಹೆಡರ್ ಕಡತಗಳನ್ನು ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ.

219
00:13:19,000 --> 00:13:21,000
ಓಹ್, ಇಂಟ್ X. ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಎಂದು ನೆನಪಿಡುವ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

220
00:13:21,000 --> 00:13:24,000
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ವಿಲ್ ಇದು ಒಂದು ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಇದನ್ನು ವೈರುಧ್ಯ

221
00:13:24,000 --> 00:13:27,000
ಸ್ವಲ್ಪ ನಂತರ ವಿಮರ್ಶೆ ಅಧಿವೇಶನದಲ್ಲಿ,

222
00:13:27,000 --> 00:13:30,000
ಮತ್ತು ನಾವು, printf ಲೈಬ್ರರಿ ಫಂಕ್ಷನ್ ಕರೆಯುತ್ತಿರುವ

223
00:13:30,000 --> 00:13:34,000
ನಾವು stdio.h ಹೆಡರ್ ಕಡತವನ್ನು ಒಳಗೊಂಡಿಲ್ಲ ಎಂದು ಹಾಗಿದ್ದಲ್ಲಿ

224
00:13:34,000 --> 00:13:37,000
ನಾವು printf ಕರೆಯಲು ಸಾಧ್ಯವಾಗುವುದಿಲ್ಲ.

225
00:13:37,000 --> 00:13:42,000
ಮತ್ತು ನಾನು ಇಲ್ಲಿ ಕತ್ತರಿಸಿ ಕೊಂಡಿರುವ ಬಾಣದ% D ತೋರುತ್ತಿರುವಂತೆ ನಂಬಿದ್ದಾರೆ

226
00:13:42,000 --> 00:13:45,000
printf ಒಂದು ಫಾರ್ಮ್ಯಾಟಿಂಗ್ ಸ್ಟ್ರಿಂಗ್ ಇದು.

227
00:13:45,000 --> 00:13:52,000
ಒಂದು ಸಂಖ್ಯೆ,% d ಈ ವೇರಿಯಬಲ್ ಮುದ್ರಿಸುತ್ತದೆ ಹೇಳುತ್ತಾರೆ.

228
00:13:52,000 --> 00:13:58,000
ಮತ್ತು ವೀಕ್ 0 ಇದು ಹೊಂದಿದೆ.

229
00:13:58,000 --> 00:14:06,000
ಈಗ ಲ್ಯೂಕಾಸ್ ಮುಂದುವರಿಸಲು ಹೋಗುತ್ತದೆ.

230
00:14:06,000 --> 00:14:08,000
ಹೇ, ವ್ಯಕ್ತಿಗಳು. ನನ್ನ ಹೆಸರು ಲ್ಯೂಕಾಸ್ ಹೊಂದಿದೆ.

231
00:14:08,000 --> 00:14:10,000
ನಾನು, ಕ್ಯಾಂಪಸ್, ಮ್ಯಾಥರ್ ಉತ್ತಮ ಮನೆಯಲ್ಲಿ ಎರಡನೆಯ ಆಮ್

232
00:14:10,000 --> 00:14:14,000
ಮತ್ತು ನಾನು ವೀಕ್ 1 ಮತ್ತು 2.1 ಕುರಿತಾಗಿ ಸ್ವಲ್ಪ ಮಾತನಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ.

233
00:14:14,000 --> 00:14:16,000
[ವೀಕ್ 1 ಮತ್ತು 2.1!] [ಲ್ಯೂಕಾಸ್ ಫ್ರೀಟಾಸ್]

234
00:14:16,000 --> 00:14:19,000
ನಾವು ಮೊದಲಿನಿಂದ ಸಿ ನಿಮ್ಮ ಕೋಡ್ ಅನುವಾದ ಆರಂಭಿಸಿದಾಗ Lexi, ಹೇಳಿಕೆಯ ಮಾಹಿತಿ

235
00:14:19,000 --> 00:14:23,000
ನಾವು ಗಮನಿಸಿದ್ದೇವೆ ವಸ್ತುಗಳ ಒಂದು ನೀವು ಕೇವಲ ಮಾಡುತ್ತದೆ

236
00:14:23,000 --> 00:14:26,000
ನಿಮ್ಮ ಕೋಡ್ ಬರೆಯಲು ಮತ್ತು ಎಂದಿಗೂ ಹಸಿರು ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಚಾಲನೆ.

237
00:14:26,000 --> 00:14:30,000
ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಸಿ ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ಕೆಲವು ಕ್ರಮಗಳನ್ನು ಬಳಸಬೇಕು

238
00:14:30,000 --> 00:14:33,000
ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಫೈಲ್ ಆಗಿ.

239
00:14:33,000 --> 00:14:36,000
ಮೂಲತಃ ನಿಮಗೆ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಬರೆಯಲು ನೀವು ನೀವು ಏನು ಎಂದು

240
00:14:36,000 --> 00:14:40,000
ನೀವು ಒಂದು ಕಂಪೈಲರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಒಂದು ಭಾಷೆಗೆ ನಿಮ್ಮ ಕಲ್ಪನೆ ಭಾಷಾಂತರಿಸಿ

241
00:14:40,000 --> 00:14:44,000
ನೀವು ಸಿ ಯೋಜನೆಯನ್ನು ನಾವು ಬರೆಯುತ್ತಿದ್ದೇವೆ ಯಾವಾಗ

242
00:14:44,000 --> 00:14:47,000
ಏನು ನೀವು ಮಾಡುತ್ತಿರುವ ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಕಂಪೈಲರ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ ಎಂದು ಏನೋ ಬರೆಯಲು ಇದೆ,

243
00:14:47,000 --> 00:14:50,000
ತದನಂತರ ಕಂಪೈಲರ್ ಕೋಡ್ ಭಾಷಾಂತರಿಸಲು ಹೋಗುತ್ತದೆ

244
00:14:50,000 --> 00:14:53,000
ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅರ್ಥ ಆ ಆಗಿ.

245
00:14:53,000 --> 00:14:55,000
>> ಮತ್ತು ವಿಷಯ, ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ವಾಸ್ತವವಾಗಿ ತುಂಬಾ ಮೂಕ ಆಗಿದೆ.

246
00:14:55,000 --> 00:14:57,000
ನಿಮ್ಮ ಗಣಕವು ಕೇವಲ, 0 ಸೆ ಮತ್ತು 1 ಅರ್ಥವಾಗುವಂತಹ

247
00:14:57,000 --> 00:15:01,000
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಮೊದಲ ಕಂಪ್ಯೂಟರ್ಗಳಲ್ಲಿ ಜನರು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರೋಗ್ರಾಮ್

248
00:15:01,000 --> 00:15:04,000
ಎಂದಿಗೂ 0 ಸೆ ಮತ್ತು 1, ಆದರೆ ಬಳಸಿಕೊಂಡು ದೇವರ ಧನ್ಯವಾದ.

249
00:15:04,000 --> 00:15:07,000
ನಾವು 0 ಸೆ ಮತ್ತು 1 ಗಾಗಿ ಅನುಕ್ರಮಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವ ಹೊಂದಿಲ್ಲ

250
00:15:07,000 --> 00:15:10,000
ಲೂಪ್ ಅಥವಾ ಸ್ವಲ್ಪ ಲೂಪ್ ಹೀಗೆ ಒಂದು ಕಾಲ.

251
00:15:10,000 --> 00:15:13,000
ನಾವು ಕಂಪೈಲರ್ ಏಕೆ ಆ.

252
00:15:13,000 --> 00:15:17,000
ಯಾವ ಒಂದು ಕಂಪೈಲರ್ ಮಾಡುತ್ತದೆ, ಇದು ಮೂಲತಃ C ಕೋಡ್ ಭಾಷಾಂತರಿಸುತ್ತದೆ ಆಗಿದೆ

253
00:15:17,000 --> 00:15:21,000
ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ಅರ್ಥ ಒಂದು ಭಾಷೆಗೆ,

254
00:15:21,000 --> 00:15:25,000
ಇದು ವಸ್ತು ಕೋಡ್, ಮತ್ತು ನಾವು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು ಕಂಪೈಲರ್ ಹೊಂದಿದೆ

255
00:15:25,000 --> 00:15:30,000
ಖಣಿಲು ಕರೆಯಲಾಗುತ್ತದೆ, ಈ ವಾಸ್ತವವಾಗಿ ಖಣಿಲು ಸಂಕೇತಿಸಿದರೆ.

256
00:15:30,000 --> 00:15:33,000
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ, ನೀವು 2 ವಿಷಯಗಳನ್ನು ಮಾಡಬೇಕು.

257
00:15:33,000 --> 00:15:37,000
ಮೊದಲ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್, ಮತ್ತು ನಂತರ ನೀವು ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಮನ್ನು ನೀನು.

258
00:15:37,000 --> 00:15:41,000
ನೀವು ಹಾಗೆ ಆಯ್ಕೆಗಳನ್ನು ಸಾಕಷ್ಟು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸಂಕಲಿಸಲು.

259
00:15:41,000 --> 00:15:44,000
ಮೊದಲ ಒಂದು ಖಣಿಲು program.c ಮಾಡಲು ಹೊಂದಿದೆ

260
00:15:44,000 --> 00:15:47,000
ಇದರಲ್ಲಿ ಪ್ರೋಗ್ರಾಂ ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು.

261
00:15:47,000 --> 00:15:51,000
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅವರು ಕೇವಲ ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು ನೋಡಬಹುದು "ಹೇ, ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್."

262
00:15:51,000 --> 00:15:56,000
ನೀವು ಅಥವಾ ಏನು "ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಈ ಹೆಸರನ್ನು ನೀವು" ಹೇಳುತ್ತಿಲ್ಲ.

263
00:15:56,000 --> 00:15:58,000
>> ಎರಡನೇ ಆಯ್ಕೆಯನ್ನು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಹೆಸರನ್ನು ನೀಡುವ ಇದೆ.

264
00:15:58,000 --> 00:16:02,000
ನೀವು ನಂತರ ಖಣಿಲು-O ಮತ್ತು ನೀವು ಬಯಸುವ ಹೆಸರನ್ನು ಹೇಳಬಹುದು

265
00:16:02,000 --> 00:16:06,000
ಫೈಲ್ ಮತ್ತು ನಂತರ program.c ಹೆಸರಿಸಿದ.

266
00:16:06,000 --> 00:16:11,000
ಮತ್ತು ನೀವು ಪ್ರೋಗ್ರಾಂ ಚಲಾಯಿಸುತ್ತಾರೆ ಮತ್ತು ಹೇಗೆ ಮೊದಲ 2 ಸಂದರ್ಭಗಳಲ್ಲಿ ನೋಡಬಹುದು

267
00:16:11,000 --> 00:16:15,000
ನಾನು. ಸಿ ಪುಟ್, ಮತ್ತು ಮೂರನೇ ಒಂದು ನಾನು ಮಾತ್ರ ಹೊಂದಿವೆ?

268
00:16:15,000 --> 00:16:18,000
ಹೌದು, ನೀವು ವಾಸ್ತವವಾಗಿ ಪುಟ್ ಮಾಡಬಾರದು. ಸಿ ನೀವು ಬಳಸಿದಾಗ.

269
00:16:18,000 --> 00:16:22,000
ಇಲ್ಲದಿದ್ದರೆ ಕಂಪೈಲರ್ ವಾಸ್ತವವಾಗಿ ನೀವು ಭಯ ಹೋಗಿ ಇದೆ.

270
00:16:22,000 --> 00:16:24,000
ನೀವು ಹುಡುಗರಿಗೆ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ವೇಳೆ ಮತ್ತು, ನಾನು, ಗೊತ್ತಿಲ್ಲ

271
00:16:24,000 --> 00:16:29,000
ಆದರೆ ನಾವು ಕೂಡ ಬಳಸಲಾಗುತ್ತದೆ-lcs50 ಅಥವಾ ಐಎಂ ಬಾರಿ ಸಾಕಷ್ಟು.

272
00:16:29,000 --> 00:16:31,000
ಆ ಲಿಂಕ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

273
00:16:31,000 --> 00:16:35,000
ಇದು ಕೇವಲ, ನೀವು ಬಲ ಅಲ್ಲಿ ಆ ಗ್ರಂಥಾಲಯಗಳು ಬಳಸುವ ಕಂಪೈಲರ್ ಹೇಳುತ್ತದೆ

274
00:16:35,000 --> 00:16:39,000
ನೀವು cs50.h ಬಳಸಲು ಬಯಸುವ ಆದ್ದರಿಂದ ನೀವು ನಿಜವಾಗಿಯೂ ಟೈಪ್ ಮಾಡಬೇಕು

275
00:16:39,000 --> 00:16:43,000
ಖಣಿಲು program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
ನೀವು ಮಾಡದಿದ್ದರೆ, ಕಂಪೈಲರ್ ತಿಳಿಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ

277
00:16:45,000 --> 00:16:50,000
ನೀವು cs50.h. ಆ ಕಾರ್ಯಗಳನ್ನು ಬಳಸುತ್ತಿದ್ದೀರಿ ಎಂಬುದನ್ನು

278
00:16:50,000 --> 00:16:52,000
ಮತ್ತು ನೀವು 2 ಆಯ್ಕೆಗಳು ನಿಮ್ಮ ಪ್ರೊಗ್ರಾಮನ್ನು ಬಯಸಿದಾಗ.

279
00:16:52,000 --> 00:16:57,000
ನೀವು ಖಣಿಲು program.c ಮಾಡಿದರೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಹೆಸರನ್ನು ಬಳಸಲಿಲ್ಲ.

280
00:16:57,000 --> 00:17:01,000
ನೀವು. / A.out ಬಳಸಿ ಚಾಲನೆ ಮಾಡಬೇಕು.

281
00:17:01,000 --> 00:17:06,000
A.out ನೀವು ಒಂದು ಹೆಸರನ್ನು ನೀಡದಿದ್ದಲ್ಲಿ ಖಣಿಲು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮವನ್ನು ನೀಡುವ ಒಂದು ಸಾಮಾನ್ಯ ಹೆಸರಾಗಿದೆ.

282
00:17:06,000 --> 00:17:11,000
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಒಂದು ಹೆಸರನ್ನು ನೀಡಿದರು, ಇಲ್ಲದಿದ್ದರೆ ನೀವು. / ಪ್ರೋಗ್ರಾಂ ಮಾಡಲು ನೀನು,

283
00:17:11,000 --> 00:17:15,000
ನೀವು ಪ್ರೋಗ್ರಾಂ ಹೆಸರು ಮಾಡಿದರು ವೇಳೆ ಮತ್ತು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಕಾಣುವುದು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ

284
00:17:15,000 --> 00:17:23,000
ಈಗಾಗಲೇ ಸಿ ಕಡತ ಹೆಸರಿನ ಪ್ರೋಗ್ರಾಮ್ ಏರಲಿದೆ.

285
00:17:23,000 --> 00:17:26,000
ನಂತರ ನಾವು ಡೇಟಾ ವಿಧಾನಗಳು ಮತ್ತು ಮಾಹಿತಿ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು.

286
00:17:26,000 --> 00:17:31,000
>> ಮೂಲತಃ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಅವರು ಬಳಸುವ ಸಣ್ಣ ಪೆಟ್ಟಿಗೆಗಳು ಅದೇ ಆಗಿವೆ

287
00:17:31,000 --> 00:17:35,000
ಮೌಲ್ಯಗಳು ಶೇಖರಿಸಿಡಲು, ಆದ್ದರಿಂದ ಡೇಟಾ ಪ್ರಕಾರಗಳು ಕೇವಲ Pokémons ನಂತಹ ವಾಸ್ತವವಾಗಿ.

288
00:17:35,000 --> 00:17:39,000
ಅವರು ಎಲ್ಲಾ ಗಾತ್ರಗಳು ಮತ್ತು ರೀತಿಗಳಲ್ಲಿ ಬರುತ್ತವೆ.

289
00:17:39,000 --> 00:17:43,000
ಸಾದೃಶ್ಯವು ಅರ್ಥವಿಲ್ಲ ವೇಳೆ ನನಗೆ ಗೊತ್ತಿಲ್ಲ.

290
00:17:43,000 --> 00:17:46,000
ಡೇಟಾವನ್ನು ಗಾತ್ರವು ನಿಜವಾಗಿ ಯಂತ್ರದ ವಿನ್ಯಾಸದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

291
00:17:46,000 --> 00:17:49,000
ನಾನು ಇಲ್ಲಿ ತೋರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಗಾತ್ರಗಳು

292
00:17:49,000 --> 00:17:53,000
ನಮ್ಮ APPLIANCE ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರ, ಫಾರ್ ವಾಸ್ತವವಾಗಿ

293
00:17:53,000 --> 00:17:56,000
ಆದರೆ ನೀವು ನಿಜವಾಗಿಯೂ ನಿಮ್ಮ ಮ್ಯಾಕ್ ಅಥವಾ ವಿಂಡೋಸ್ ಕೂಡ ಕೋಡಿಂಗ್ ಮಾತ್ರ

294
00:17:56,000 --> 00:17:59,000
ಬಹುಶಃ ನೀವು, ಒಂದು 64 ಬಿಟ್ ಯಂತ್ರ ಹೊಂದಿರುವ ನೀನು

295
00:17:59,000 --> 00:18:03,000
ಆದ್ದರಿಂದ ನಾನು ಹೋಗುತ್ತಿರುವೆ ಡೇಟಾವನ್ನು ಗಾತ್ರಗಳು ಇಲ್ಲಿ ತೋರಿಸಲು ನೆನಪು

296
00:18:03,000 --> 00:18:06,000
32-ಬಿಟ್ ಯಂತ್ರ ಹೊಂದಿದೆ.

297
00:18:06,000 --> 00:18:08,000
ನಾವು ನೋಡಿದ ಪ್ರಥಮ ಒಂದು, ಒಂದು int ಆಗಿತ್ತು

298
00:18:08,000 --> 00:18:10,000
ಇದು ಬಹಳ ನೇರವಾಗಿದೆ.

299
00:18:10,000 --> 00:18:13,000
ನೀವು ಒಂದು ಪೂರ್ಣಾಂಕ ಶೇಖರಿಸಿಡಲು ಇಂಟ್ ಬಳಸಿ.

300
00:18:13,000 --> 00:18:16,000
ನಾವು ಪಾತ್ರ ಚಾರ್ ಕಂಡಿತು.

301
00:18:16,000 --> 00:18:20,000
ನೀವು ಒಂದು ಅಕ್ಷರ ಅಥವಾ ಸ್ವಲ್ಪ ಚಿಹ್ನೆಯನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ ನೀವು ಬಹುಶಃ ಚಾರ್ ಬಳಸಲು ನೀನು.

302
00:18:20,000 --> 00:18:26,000
ಎ ಚಾರ್ Lexi ಹೇಳಿದರು ನಂತಹ 8 ಬಿಟ್ಗಳು, ಅಂದರೆ 1 ಬೈಟ್ ಹೊಂದಿದೆ.

303
00:18:26,000 --> 00:18:31,000
ಮೂಲಭೂತವಾಗಿ ನಾವು 256 ಹೊಂದಿರುವ ASCII ಟೇಬಲ್ ಹೊಂದಿರುತ್ತದೆ

304
00:18:31,000 --> 00:18:34,000
0 ಸೆ ಮತ್ತು 1 ಗಳ ಸಂಭಾವ್ಯ ಸಂಯೋಜನೆಗಳಿಂದ,

305
00:18:34,000 --> 00:18:37,000
ತದನಂತರ ನೀವು ಚಾರ್ ಟೈಪ್ ಮಾಡಿದಾಗ ಅದನ್ನು ಭಾಷಾಂತರಿಸಲು ವಿಶೇಷವೇನು

306
00:18:37,000 --> 00:18:44,000
ಪಾತ್ರದ ಒಳಹರಿವು ನೀವು Lexi ನಂತಹ, ASCII ಕೋಷ್ಟಕದಲ್ಲಿ ಹೊಂದಿರುವ ಹಲವಾರು ಹೇಳಿದ್ದಾರೆ.

307
00:18:44,000 --> 00:18:48,000
ನಾವು ದಶಮಾಂಶ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸುವ ಫ್ಲೋಟ್ ಹೊಂದಿರುತ್ತವೆ.

308
00:18:48,000 --> 00:18:53,000
ನೀವು 3,14 ಆಯ್ಕೆ ಬಯಸಿದರೆ, ಉದಾಹರಣೆಗೆ, ನೀವು ಒಂದು ಫ್ಲೋಟ್ ಬಳಸಲು ನೀನು

309
00:18:53,000 --> 00:18:55,000
ಅಥವಾ ಹೆಚ್ಚಿನ ನಿಖರತೆಯನ್ನು ಹೊಂದಿರುವ ಎರಡು.

310
00:18:55,000 --> 00:18:57,000
ಒಂದು ಫ್ಲೋಟ್ 4 ಬೈಟ್ಗಳು ಹೊಂದಿದೆ.

311
00:18:57,000 --> 00:19:01,000
ಒಂದು ಜೋಡಿ 8 ಬೈಟ್ಗಳು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಕೇವಲ ವ್ಯತ್ಯಾಸ PRECISION ಹೊಂದಿದೆ.

312
00:19:01,000 --> 00:19:04,000
ನಾವು, ಪೂರ್ಣಾಂಕಗಳು ಬಳಸುವ ಬಹಳ ಹೊಂದಿವೆ

313
00:19:04,000 --> 00:19:09,000
ಮತ್ತು, ಒಂದು int ಮತ್ತು ದೀರ್ಘ ಒಂದೇ ಗಾತ್ರ ಹೊಂದಿವೆ ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರದ ನೋಡಬಹುದು

314
00:19:09,000 --> 00:19:13,000
ಆದ್ದರಿಂದ ಇದು ನಿಜವಾಗಿಯೂ ಒಂದು 32 ಬಿಟ್ ಯಂತ್ರದಲ್ಲಿ ಬಹಳ ಬಳಸಲು ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

315
00:19:13,000 --> 00:19:17,000
>> ನೀವು ಮ್ಯಾಕ್ ಮತ್ತು 64 ಬಿಟ್ ಯಂತ್ರ ಬಳಸುತ್ತಿರುವ ಆದರೆ, ವಾಸ್ತವವಾಗಿ ಒಂದು ಉದ್ದ, ಗಾತ್ರ 8 ಹೊಂದಿದೆ

316
00:19:17,000 --> 00:19:19,000
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ವಿನ್ಯಾಸದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆ.

317
00:19:19,000 --> 00:19:22,000
32-ಬಿಟ್ ಯಂತ್ರ ಇದು ನಿಜವಾಗಿಯೂ ಬಹಳ ಬಳಸಲು ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

318
00:19:22,000 --> 00:19:25,000
ಮತ್ತು ನಂತರ ಒಂದು ದೀರ್ಘ ದೀರ್ಘ, ಮತ್ತೊಂದೆಡೆ, 8 ಬೈಟ್ಗಳು ಹೊಂದಿದೆ

319
00:19:25,000 --> 00:19:30,000
ನೀವು ಮುಂದೆ ಪೂರ್ಣಾಂಕ ಬೇಕು ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಒಳ್ಳೆಯದು.

320
00:19:30,000 --> 00:19:34,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು, ವಾಸ್ತವವಾಗಿ ಒಂದು ಚಾರ್ * ಇದು, ದಾರಗಳನ್ನು

321
00:19:34,000 --> 00:19:37,000
ಒಂದು ಹಾಳೆಯನ್ನು ಒಂದು ಸೂಚಿಯಾಗಿದೆ.

322
00:19:37,000 --> 00:19:40,000
ಇದು ತಂತುವಿನ ಗಾತ್ರ ಹಾಗೆ ಹೋಗುತ್ತದೆ ಭಾವಿಸುತ್ತೇನೆ ಬಹಳ ಸುಲಭ

323
00:19:40,000 --> 00:19:42,000
ನೀವು ಹೊಂದಿರುವ ಪಾತ್ರಗಳ ಸಂಖ್ಯೆ,

324
00:19:42,000 --> 00:19:45,000
ಆದರೆ ವಾಸ್ತವವಾಗಿ ಚಾರ್ * ಸ್ವತಃ

325
00:19:45,000 --> 00:19:49,000
4 ಬೈಟ್ಗಳು ಇದು ಚಾರ್, ಒಂದು ಪಾಯಿಂಟರ್ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ.

326
00:19:49,000 --> 00:19:52,000
ಒಂದು ಚಾರ್ * ಗಾತ್ರವನ್ನು 4 ಬೈಟ್ಸ್.

327
00:19:52,000 --> 00:19:56,000
ನೀವು ಒಂದು ಸಣ್ಣ ಪದ ಅಥವಾ ಅಕ್ಷರ ಅಥವಾ ಏನು ಹೊಂದಿದ್ದರೆ ಅದು ಲೆಕ್ಕಕ್ಕೆ ಬರುವುದಿಲ್ಲ.

328
00:19:56,000 --> 00:19:58,000
ಇದು 4 ಬೈಟ್ಗಳು ಎಂದು ವಿಶೇಷವೇನು.

329
00:19:58,000 --> 00:20:01,000
ನಾವು, CASTING ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಕಲಿತ

330
00:20:01,000 --> 00:20:04,000
ನೀವು ಹೊಂದಿದ್ದರೆ ನೀವು ನೋಡಬಹುದು ಎಂದು, ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರೋಗ್ರಾಂ ಹೇಳುತ್ತದೆ

331
00:20:04,000 --> 00:20:08,000
ಇಂಟ್ x = 3 ತದನಂತರ printf ("% s", X / 2)

332
00:20:08,000 --> 00:20:12,000
ನೀವು ಹುಡುಗರಿಗೆ ಇದು ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸಲು ವಿಶೇಷವೇನು ಏನು ಗೊತ್ತೇ?

333
00:20:12,000 --> 00:20:14,000
>> ಯಾರೋ? >> [ವಿದ್ಯಾರ್ಥಿಗಳು] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, ಹೌದು.

335
00:20:16,000 --> 00:20:20,000
3/2 ಮಾಡಿದಾಗ ಅದು 1.5 ಪಡೆಯಲು ವಿಶೇಷವೇನು

336
00:20:20,000 --> 00:20:24,000
ನಾವು ಒಂದು ಪೂರ್ಣಾಂಕ ಬಳಸುತ್ತಿರುವ ಕಾರಣ ಆದರೆ, ದಶಮಾಂಶ ಭಾಗವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಲು ವಿಶೇಷವೇನು

337
00:20:24,000 --> 00:20:26,000
ಮತ್ತು ನೀವು 1 ಹೊಂದಿವೆ ಎಂದು ನೀನು.

338
00:20:26,000 --> 00:20:29,000
ನೀವು, ಉದಾಹರಣೆಗೆ, ನೀವು ಏನು ಮಾಡಬಹುದು ತೀರುತ್ತದೆ ಬಯಸದಿದ್ದರೆ

339
00:20:29,000 --> 00:20:33,000
ಒಂದು ಫ್ಲೋಟ್ ಘೋಷಿಸಲು ಇದೆ Y = X.

340
00:20:33,000 --> 00:20:40,000
ನಂತರ 3 ಎಂದು ಬಳಸಿದ X ಈಗ ವೈ ರಲ್ಲಿ 3,000 ಏರಲಿದೆ.

341
00:20:40,000 --> 00:20:44,000
ತದನಂತರ ನೀವು ವೈ / 2 ಮುದ್ರಿಸಬಹುದು.

342
00:20:44,000 --> 00:20:50,000
ವಾಸ್ತವವಾಗಿ, ನಾನು 2 ಇರಬೇಕು. ಆ.

343
00:20:50,000 --> 00:20:55,000
ಇದು 3.00/2.00 ಮಾಡಲು ವಿಶೇಷವೇನು

344
00:20:55,000 --> 00:20:58,000
ಮತ್ತು ನೀವು 1.5 ಪಡೆಯಲು ನೀನು.

345
00:20:58,000 --> 00:21:06,000
ಮತ್ತು ನಾವು ದಶಮಾಂಶ ಭಾಗದಲ್ಲಿ 2 ದಶಮಾಂಶ ಘಟಕಗಳಿಗೆ ಕೇಳಲು ಈ .2 f ನ.

346
00:21:06,000 --> 00:21:12,000
ನೀವು .3 F ಹೊಂದಿದ್ದರೆ ನಿಜವಾಗಿ 1.500 ಇರುತ್ತವೆ ಹೊಂದಲು ವಿಶೇಷವೇನು.

347
00:21:12,000 --> 00:21:16,000
ಅದು ವೇಳೆ 2 ಇದು 1.50 ಎಂದು ವಿಶೇಷವೇನು.

348
00:21:16,000 --> 00:21:18,000
ನಾವು ಇಲ್ಲಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ.

349
00:21:18,000 --> 00:21:22,000
ನೀವು ಫ್ಲೋಟ್ ಮಾಡಿದರೆ X = 3,14 ಮತ್ತು ನಂತರ ನೀವು printf X

350
00:21:22,000 --> 00:21:24,000
ನೀವು 3,14 ಪಡೆಯಲು ನೀನು.

351
00:21:24,000 --> 00:21:29,000
ಮತ್ತು ನೀವು ವೇಳೆ X x ನ = ಇಂಟ್,

352
00:21:29,000 --> 00:21:34,000
ಒಂದು ಇಂಟ್ ಮಾಹಿತಿ X ಚಿಕಿತ್ಸೆ ಅರ್ಥ ಮತ್ತು ನೀವು ಈಗ X ಮುದ್ರಿಸಲು ಇದು

353
00:21:34,000 --> 00:21:36,000
ನೀವು 3.00 ಹೊಂದಿರುವ ನೀನು.

354
00:21:36,000 --> 00:21:38,000
ಎಂದು ಅರ್ಥ ಡಸ್?

355
00:21:38,000 --> 00:21:41,000
ನೀವು ಮೊದಲು ಒಂದು ಪೂರ್ಣಾಂಕವಾಗಿ X ಚಿಕಿತ್ಸೆ ಆಗಿರುವ ಕಾರಣ, ಆದ್ದರಿಂದ ನೀವು ದಶಮಾಂಶ ಭಾಗವನ್ನು ಉಪೇಕ್ಷಿಸಿ ನೀವು

356
00:21:41,000 --> 00:21:45,000
ತದನಂತರ ನೀವು X ಮುದ್ರಣ ಮಾಡುತ್ತಿದ್ದೇವೆ.

357
00:21:45,000 --> 00:21:47,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನೀವು, ಈ ಮಾಡಬಹುದು

358
00:21:47,000 --> 00:21:52,000
ಇಂಟ್ x = 65, ಮತ್ತು ನಂತರ ನೀವು ಚಾರ್ ಸಿ = X ಘೋಷಿಸಿದ,

359
00:21:52,000 --> 00:21:56,000
ನೀವು ಸಿ ಮುದ್ರಿಸಲು ವೇಳೆ ಮತ್ತು ನಂತರ ನೀವು ನಿಜವಾಗಿಯೂ ಪಡೆಯಲು ನೀನು

360
00:21:56,000 --> 00:21:59,000
ಒಂದು, ನೀವು ಇಲ್ಲಿ ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಏನು ಮಾಡುತ್ತಿದ್ದೇವೆ

361
00:21:59,000 --> 00:22:02,000
, ಪಾತ್ರದ ಗೆ ಪೂರ್ಣಾಂಕ ಅನುವಾದ ಇದೆ

362
00:22:02,000 --> 00:22:05,000
ಕೇವಲ ರೀತಿಯ ASCII ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.

363
00:22:05,000 --> 00:22:08,000
ನಾವು ಗಣಿತ ನಿರ್ವಾಹಕರು ಬಗ್ಗೆ ಮಾತನಾಡಿದರು.

364
00:22:08,000 --> 00:22:14,000
ಅವುಗಳಲ್ಲಿ ಅತ್ಯಂತ ಬಹಳ ಸರಳವಾಗಿದ್ದು, ಆದ್ದರಿಂದ +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
ಮತ್ತು ನಾವು 2 ಸಂಖ್ಯೆಗಳ ವಿಭಾಗ ಉಳಿದ ಇದು ಮೋಡ್ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು.

366
00:22:20,000 --> 00:22:23,000
ನೀವು ಉದಾಹರಣೆಗೆ 10% 3, ಇದ್ದರೆ

367
00:22:23,000 --> 00:22:27,000
ಇದು 3 ರಿಂದ 10 ಭಾಗಿಸಿ ಎಂದರ್ಥ, ಮತ್ತು ಉಳಿದ ಏನು?

368
00:22:27,000 --> 00:22:30,000
ಇದು 1 ಎಂದು, ಆದ್ದರಿಂದ ಇದು ಕಾರ್ಯಕ್ರಮಗಳು ಸಾಕಷ್ಟು ನಿಜವಾಗಿ ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿರುವ.

369
00:22:30,000 --> 00:22:38,000
Vigenère ಮತ್ತು ಸೀಸರ್ ನಾನು ನೀವು ಹುಡುಗರಿಗೆ ಎಲ್ಲಾ ಮಾಡ್ ಬಳಸಿದ ಬಹಳ ನನಗೆ ಖಾತ್ರಿಯಿದೆ.

370
00:22:38,000 --> 00:22:43,000
* ಮತ್ತು / ಸಂಯೋಜಿಸಿದಾಗ ಗಣಿತ ನಿರ್ವಾಹಕರು ಬಗ್ಗೆ, ಜಾಗ್ರತೆಯಿಂದಿರಬೇಕು.

371
00:22:43,000 --> 00:22:48,000
>> ನೀವು ಉದಾಹರಣೆಗೆ, (3/2) * 2 ಏನು ಪಡೆಯಲು ಹೋಗುವ?

372
00:22:48,000 --> 00:22:50,000
[ವಿದ್ಯಾರ್ಥಿಗಳು] 2.

373
00:22:50,000 --> 00:22:54,000
ಹೌದು, 2, 3/2 ಕಾರಣ 1.5 ಎಂದು ಹೋಗುತ್ತದೆ,

374
00:22:54,000 --> 00:22:57,000
ಆದರೆ ನೀವು 2 ಪೂರ್ಣಾಂಕಗಳ ನಡುವೆ ಕಾರ್ಯಾಚರಣೆಗಳ ಮಾಡುತ್ತಿರುವುದು ರಿಂದ

375
00:22:57,000 --> 00:22:59,000
ನಿಜವಾಗಿಯೂ, ಕೇವಲ 1 ಪರಿಗಣಿಸಲು ನೀನು

376
00:22:59,000 --> 00:23:03,000
ನಂತರ 1 * 2 2 ಎಂದು ಹೋಗುತ್ತದೆ, ಆದ್ದರಿಂದ ತುಂಬಾ ಜಾಗರೂಕರಾಗಿರಿ

377
00:23:03,000 --> 00:23:07,000
ಪೂರ್ಣಾಂಕಗಳ ಜೊತೆ ಅಂಕಗಣಿತದ ಮಾಡುವಾಗ ಏಕೆಂದರೆ

378
00:23:07,000 --> 00:23:12,000
ಆ ಸಂದರ್ಭದಲ್ಲಿ, 2 = 3 ಸಿಗುತ್ತವೆ.

379
00:23:12,000 --> 00:23:14,000
ಮತ್ತು ಅಗ್ರಸ್ಥಾನವನ್ನು ಬಗ್ಗೆ ಜಾಗರೂಕರಾಗಿರಿ.

380
00:23:14,000 --> 00:23:21,000
ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಮಾಡುವ ಏನನ್ನು ತಿಳಿಯಲು ಖಚಿತವಾಗಿ ಎಂದು ಆವರಣ ಬಳಸಬೇಕು.

381
00:23:21,000 --> 00:23:27,000
ಕೆಲವು ಉಪಯುಕ್ತ ಶಾರ್ಟ್ಕಟ್ಗಳನ್ನು, ಸಹಜವಾಗಿ, ಒಂದು ನಾನು + + ಅಥವಾ i + 1 =

382
00:23:27,000 --> 00:23:30,000
ಅಥವಾ ಬಳಸಿಕೊಂಡು + =.

383
00:23:30,000 --> 00:23:34,000
ನಾನು = ನಾನು + 1 ಮಾಡುವ ಅದೇ ವಿಷಯ.

384
00:23:34,000 --> 00:23:39,000
ನೀವು ನಾನು ಮಾಡಬಹುದು - ಅಥವಾ ನಾನು - = 1,

385
00:23:39,000 --> 00:23:42,000
ಇದು, ನಾನು = ನಾನು -1 ಅದೇ ವಿಷಯ

386
00:23:42,000 --> 00:23:46,000
ಏನೋ ನೀವು ಹುಡುಗರಿಗೆ ಕನಿಷ್ಠ ಕುಣಿಕೆಗಳು ಗಾಗಿ ಬಹಳಷ್ಟು ಬಳಸಿ.

387
00:23:46,000 --> 00:23:52,000
ಸಹ, *, ನೀವು * = ಮತ್ತು ನೀವು ಹೋದರೆ, ಉದಾಹರಣೆಗೆ ಬಳಸುತ್ತಿದ್ದರೆ,

388
00:23:52,000 --> 00:23:57,000
ನಾನು * = 2 ನಾನು = ನಾನು * 2 ಹೇಳುವ ಅದೇ ವಿಷಯ,

389
00:23:57,000 --> 00:23:59,000
ಮತ್ತು ವಿಭಾಗಕ್ಕೆ ಒಂದೇ.

390
00:23:59,000 --> 00:24:08,000
ನೀವು ನಾನು / = 2 ಮಾಡಿದರೆ ನಾನು = I / 2 ಅದೇ ವಿಷಯ.

391
00:24:08,000 --> 00:24:10,000
>> ಈಗ ಕಾರ್ಯಗಳನ್ನು ಬಗ್ಗೆ.

392
00:24:10,000 --> 00:24:13,000
ನೀವು ಹುಡುಗರಿಗೆ ಕಾರ್ಯಗಳನ್ನು ಕೋಡ್ ಉಳಿಸಲು ಉತ್ತಮ ತಂತ್ರ ಕಲಿತಿದ್ದು

393
00:24:13,000 --> 00:24:16,000
ನೀವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುತ್ತಲೇ, ನೀವು ಕೆಲಸವನ್ನು ನಿರ್ವಹಿಸಲು ಬಯಸಿದಲ್ಲಿ

394
00:24:16,000 --> 00:24:20,000
ಕೋಡ್ ಮತ್ತೆ ಮತ್ತೆ, ಪ್ರಾಯಶಃ ನೀವು ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಬಯಸುವ

395
00:24:20,000 --> 00:24:25,000
ಕೇವಲ ಆದ್ದರಿಂದ ನೀವು ಮತ್ತೊಮ್ಮೆ ಮತ್ತು ಮೇಲೆ ಕೋಡ್ ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ ಇಲ್ಲ.

396
00:24:25,000 --> 00:24:28,000
ವಾಸ್ತವವಾಗಿ, ಮುಖ್ಯ ಕಾರ್ಯ, ಮತ್ತು ನಾನು ಒಂದು ಕ್ರಿಯೆಯ ಸ್ವರೂಪ ಪ್ರದರ್ಶಿಸಿದಾಗ

397
00:24:28,000 --> 00:24:32,000
ನೀವು ಸಾಕಷ್ಟು ಸ್ಪಷ್ಟವಾಗಿರುವ ನೋಡಲು ನೀನು.

398
00:24:32,000 --> 00:24:35,000
ನಾವು ಕೆಲವು ಲೈಬ್ರರಿಗಳಿಂದ ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿ

399
00:24:35,000 --> 00:24:39,000
ಉದಾಹರಣೆಗೆ, printf, CS50 ಲೈಬ್ರರಿಯಿಂದ ಇದು GetIn,

400
00:24:39,000 --> 00:24:43,000
ಮತ್ತು toupper ಇತರ ಕಾರ್ಯಗಳು.

401
00:24:43,000 --> 00:24:46,000
ಆ ಕಾರ್ಯಗಳನ್ನು ಎಲ್ಲಾ ವಾಸ್ತವವಾಗಿ, ಇತರ ಗ್ರಂಥಾಲಯಗಳು ಅಳವಡಿಸಲಾಗಿದೆ

402
00:24:46,000 --> 00:24:49,000
ಮತ್ತು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಪ್ರಾರಂಭದಲ್ಲಿ ಆ tether ಕಡತಗಳನ್ನು ಹುಟ್ಟುಹಾಕಿದಾಗ

403
00:24:49,000 --> 00:24:53,000
ನೀವು ನನ್ನನ್ನು ಆ ಕಾರ್ಯಗಳನ್ನು ಕೋಡ್ ನೀಡಿ ಮಾಡಬಹುದು ಹೇಳುತ್ತಿದ್ದಾರೆಂಬುದನ್ನು

404
00:24:53,000 --> 00:24:57,000
ಆದ್ದರಿಂದ ನಾನು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಲ್ಲ?

405
00:24:57,000 --> 00:25:00,000
ಮತ್ತು ನೀವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಪ್ರಾರಂಭಿಸಿದಾಗ ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಸ್ವಂತ ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಬಹುದು

406
00:25:00,000 --> 00:25:04,000
ನೀವು ಗ್ರಂಥಾಲಯಗಳು ನೀವು ಎಲ್ಲಾ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ ಎಂಬುದನ್ನು.

407
00:25:04,000 --> 00:25:10,000
ಕೊನೆಯ pset ಉದಾಹರಣೆಗೆ,, ನಾವು, ಸ್ಕ್ರಾಂಬಲ್ ಸೆಳೆಯುತ್ತವೆ, ಮತ್ತು ನೋಡುವಿಕೆಯನ್ನು ಬರೆದರು

408
00:25:10,000 --> 00:25:13,000
ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ಬರೆಯಲು ಮಾಡಲು ತುಂಬಾ ಮುಖ್ಯ

409
00:25:13,000 --> 00:25:17,000
ಅವರು ಉಪಯುಕ್ತ, ಹಾಗೂ ನಾವು ಅವುಗಳನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಲ್ಲಾ ಸಮಯದಲ್ಲಿ ಬಳಸಲು ಕಾರಣ,

410
00:25:17,000 --> 00:25:19,000
ಮತ್ತು ಇದು ಕೋಡ್ ಸಾಕಷ್ಟು ಉಳಿಸುತ್ತದೆ.

411
00:25:19,000 --> 00:25:21,000
ಒಂದು ಕ್ರಿಯೆಯ ಸ್ವರೂಪವನ್ನು ಈ ಒಂದಾಗಿದೆ.

412
00:25:21,000 --> 00:25:24,000
ನಾವು ಆರಂಭದಲ್ಲಿ ಲಾಭ ರೀತಿಯ. ರಿಟರ್ನ್ ಪ್ರಕಾರ ಯಾವುದು?

413
00:25:24,000 --> 00:25:27,000
ನಿಮ್ಮ ಕಾರ್ಯ ಮರಳಲು ಹತ್ತಿದರೆ ಜಸ್ಟ್.

414
00:25:27,000 --> 00:25:29,000
ನೀವು ಅಪವರ್ತನೀಯ ಉದಾಹರಣೆಗೆ ಒಂದು ಕ್ರಿಯೆ, ಇದ್ದರೆ

415
00:25:29,000 --> 00:25:31,000
ಎಂದು, ಒಂದು ಪೂರ್ಣಾಂಕ ಒಂದು ಅಪವರ್ತನೀಯ ಲೆಕ್ಕ ಹಾಕುತ್ತದೆ

416
00:25:31,000 --> 00:25:34,000
ಬಹುಶಃ ಇದು ಒಂದು ಪೂರ್ಣಾಂಕ ಮರಳಲು ವಿಶೇಷವೇನು.

417
00:25:34,000 --> 00:25:37,000
ನಂತರ ಮರಳಿ ರೀತಿಯ ಇಂಟ್ ಏರಲಿದೆ.

418
00:25:37,000 --> 00:25:41,000
Printf ವಾಸ್ತವವಾಗಿ ಒಂದು ರಿಟರ್ನ್ ರೀತಿಯ ಶೂನ್ಯವನ್ನು ಹೊಂದಿದೆ

419
00:25:41,000 --> 00:25:43,000
ನೀವು ಏನು ಹಿಂದಿರುಗಿದ ಆಗದೇ ಇರುವ ಕಾರಣ.

420
00:25:43,000 --> 00:25:45,000
ನೀವು ತೆರೆಯ ವಿಷಯಗಳನ್ನು ಮುದ್ರಿಸುವ ನೀವು

421
00:25:45,000 --> 00:25:48,000
ನಂತರ ಕಾರ್ಯ ತೊರೆದು.

422
00:25:48,000 --> 00:25:51,000
ನಂತರ ನೀವು ಆಯ್ಕೆ ಮಾಡುವ ಕ್ರಿಯೆಯ ಹೆಸರನ್ನು ಹೊಂದಿವೆ.

423
00:25:51,000 --> 00:25:55,000
XYZ ಒಂದು ಹೆಸರನ್ನು ಆಯ್ಕೆ ಇಲ್ಲ ನಿಮಗೆ, ಸ್ವಲ್ಪ ಸಮಂಜಸವಾದ ಆಗಿರಬೇಕು

424
00:25:55,000 --> 00:25:58,000
ಅಥವಾ x2f ನಂತಹ.

425
00:25:58,000 --> 00:26:02,000
ಅರ್ಥವನ್ನು ನೀಡುವ ಒಂದು ಹೆಸರನ್ನು ಅಪ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ.

426
00:26:02,000 --> 00:26:04,000
>> ಉದಾಹರಣೆಗೆ, ಇದು ಅಪವರ್ತನೀಯ ಇದ್ದರೆ, ಅಪವರ್ತನೀಯ ಹೇಳುತ್ತಾರೆ.

427
00:26:04,000 --> 00:26:08,000
ಯಾವುದನ್ನಾದರೂ ಸೆಳೆಯಲು ಹೋಗುತ್ತದೆ ಒಂದು ಫಂಕ್ಷನ್ ಅದನ್ನು ಡ್ರಾ ಹೆಸರು.

428
00:26:08,000 --> 00:26:11,000
ನಂತರ ನಾವು ವಾದಗಳನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ಮಾನದಂಡಗಳು, ಹೊಂದಿವೆ

429
00:26:11,000 --> 00:26:14,000
ನಿಮ್ಮ ಕಾರ್ಯ ಅಗತ್ಯವಿರುವ ಸಂಪನ್ಮೂಲಗಳನ್ನು ರೀತಿಯಲ್ಲಿ ಇವು

430
00:26:14,000 --> 00:26:17,000
ನಿಮ್ಮ ಕೋಡ್ ಅದರ ಕಾರ್ಯ ನಿರ್ವಹಿಸಲು.

431
00:26:17,000 --> 00:26:20,000
ನೀವು ಒಂದು ಸಂಖ್ಯೆಯ ಅಪವರ್ತನೀಯ ಲೆಕ್ಕ ಬಯಸಿದರೆ

432
00:26:20,000 --> 00:26:23,000
ಬಹುಶಃ ನೀವು ಅಪವರ್ತನೀಯ ಲೆಕ್ಕಹಾಕಲು ಒಂದು ಸಂಖ್ಯೆಯ ಅಗತ್ಯವಿದೆ.

433
00:26:23,000 --> 00:26:27,000
ನೀವು ಎಂದು ನೀನು ಆ ವಾದಗಳಲ್ಲಿ ಒಂದು ಸಂಖ್ಯೆ ಆಗಿದೆ.

434
00:26:27,000 --> 00:26:31,000
ನಂತರ ಅದನ್ನು ಏನಾದರೂ ಮತ್ತು ಕೊನೆಯಲ್ಲಿ ಮೌಲ್ಯವನ್ನು ಮರಳಲು ವಿಶೇಷವೇನು

435
00:26:31,000 --> 00:26:35,000
ಇದು ಶೂನ್ಯವನ್ನು ಕಾರ್ಯ ದ ಹೊರತು.

436
00:26:35,000 --> 00:26:37,000
ನ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

437
00:26:37,000 --> 00:26:40,000
ನಾನು, ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳು ಸಂಯೋಜಿಸುತ್ತಾನೆ ಒಂದು ಫಂಕ್ಷನ್ ಬರೆಯಲು ಬಯಸಿದರೆ

438
00:26:40,000 --> 00:26:43,000
ಎಲ್ಲಾ ಮೊದಲ, ರಿಟರ್ನ್ ಪ್ರಕಾರ ಇಂಟ್ ಏರಲಿದೆ

439
00:26:43,000 --> 00:26:46,000
ನಾನು ಪೂರ್ಣಾಂಕಗಳ ವ್ಯೂಹದ ಕಾರಣ.

440
00:26:46,000 --> 00:26:51,000
ಆಗ ನಾನು, sumArray ನಂತಹ ಕಾರ್ಯವನ್ನು ಹೆಸರನ್ನು ಹೊಂದಲು ಪಡೆಯಲಿದ್ದೇನೆ

441
00:26:51,000 --> 00:26:54,000
ನಂತರ ಅದನ್ನು, ಇಂಟ್ nums ಗೆ, ಸರಣಿ ಸ್ವತಃ ತೆಗೆದುಕೊಳ್ಳುವುದು

442
00:26:54,000 --> 00:26:58,000
ತದನಂತರ ನಾನು ಮೊತ್ತಕ್ಕೆ ಎಷ್ಟು ಸಂಖ್ಯೆಗಳನ್ನು ತಿಳಿದಿರುವುದರಿಂದ ರಚನೆಯ ಉದ್ದ.

443
00:26:58,000 --> 00:27:02,000
ನಂತರ ನಾನು 0 ಉದಾಹರಣೆಗೆ ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂಬ ಮೊತ್ತವು, ಆರಂಭಿಸಲು ಹೊಂದಿವೆ

444
00:27:02,000 --> 00:27:08,000
ಮತ್ತು ನಾನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಒಂದು ಅಂಶ ನೋಡಿ ಪ್ರತಿ ಬಾರಿ ನಾನು ಮೊತ್ತವು ಇದನ್ನು ಸೇರಿಸಬೇಕು, ಆದ್ದರಿಂದ ನಾನು ಲೂಪ್ ಒಂದು ಮಾಡಿದರು.

445
00:27:08,000 --> 00:27:15,000
Lexi ಹೇಳಿದರು ಹಾಗೆ, ನೀವು ಇಂಟ್ ನಾನು = 0, ನಾನು <ಉದ್ದ ಮತ್ತು i + +.

446
00:27:15,000 --> 00:27:20,000
ಮತ್ತು ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ನಾನು ಮೊತ್ತವು + = nums [I] ಮಾಡಿದರು,

447
00:27:20,000 --> 00:27:24,000
ತದನಂತರ ನಾನು ಮೊತ್ತವು ಮರಳಿದರು, ಆದ್ದರಿಂದ ತುಂಬಾ ಸುಲಭ, ಮತ್ತು ಅದನ್ನು ಕೋಡ್ ಸಾಕಷ್ಟು ಉಳಿಸುತ್ತದೆ

448
00:27:24,000 --> 00:27:28,000
ನೀವು ಈ ಕಾರ್ಯವನ್ನು ಬಾರಿ ಸಾಕಷ್ಟು ಬಳಸುತ್ತಿದ್ದರೆ.

449
00:27:28,000 --> 00:27:32,000
ನಾವು ಸ್ಥಿತಿಗತಿಗಳ ಅವಲೋಕನ ಮಾಡಿಕೊಂಡೆವು.

450
00:27:32,000 --> 00:27:38,000
ನಾವು ಬೇರೆ, ವೇಳೆ ಹೊಂದಿವೆ, ಮತ್ತು ಬೇರೆ ವೇಳೆ.

451
00:27:38,000 --> 00:27:42,000
ಆ ನಡುವೆ ವ್ಯತ್ಯಾಸ ಏನು ನೋಡೋಣ.

452
00:27:42,000 --> 00:27:45,000
ಈ 2 ಸಂಕೇತಗಳು ನೋಡೋಣ. ಅವುಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸ ಏನು?

453
00:27:45,000 --> 00:27:49,000
ಮೊದಲ ಒಂದು ಮೂಲಭೂತವಾಗಿ ಮಾಡಿದೆ ಸಂಕೇತಗಳು ಹೇಳಲು ಬಯಸುವ

454
00:27:49,000 --> 00:27:51,000
, ಅಥವಾ 0 - ಹಲವಾರು + ವೇಳೆ.

455
00:27:51,000 --> 00:27:55,000
ಮೊದಲ ಒಂದು ಇದು> 0 ಇದ್ದರೆ ಅದು ಧನಾತ್ಮಕ ಹೇಳುವಂತೆ.

456
00:27:55,000 --> 00:28:00,000
ಇದು 0 ಗೆ = ಆಗಿದ್ದರೆ ಅದು 0, ಮತ್ತು <0 ಇದ್ದರೆ ಅದು ನಕಾರಾತ್ಮಕವಾಗಿದೆ.

457
00:28:00,000 --> 00:28:04,000
>> ಬೇರೆ, ಬೇರೆ ವೇಳೆ, ವೇಳೆ ಮತ್ತು ಇತರ ಒಂದು ಮಾಡುತ್ತೇವೆ.

458
00:28:04,000 --> 00:28:07,000
ಎರಡು ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಈ ಒಂದು ವಾಸ್ತವವಾಗಿ ಹೋಗುವ ಇದೆ ಎಂದು

459
00:28:07,000 --> 00:28:13,000
ಪರಿಶೀಲಿಸಿ ವೇಳೆ> 0, <= 0 0 ಅಥವಾ ಮೂರು ಬಾರಿ,

460
00:28:13,000 --> 00:28:17,000
ನೀವು ಸಂಖ್ಯೆ 2 ಹಾಗಾಗಿ, ಉದಾಹರಣೆಗೆ, ಇದು ಇಲ್ಲಿ ಬಂದು ಹೇಳಲು ವಿಶೇಷವೇನು

461
00:28:17,000 --> 00:28:21,000
ಅದು ಹೌದು ಹೇಳಲು ವಿಶೇಷವೇನು (X> 0) ವೇಳೆ, ಮತ್ತು, ಆದ್ದರಿಂದ ನಾನು ಧನಾತ್ಮಕ ಮುದ್ರಿಸಿ.

462
00:28:21,000 --> 00:28:25,000
ಆದರೆ ನಾನು> 0 ಗೊತ್ತಾಯಿತು ಮತ್ತು 0 ಅಥವಾ <0 ಹಿಂದಿರುಗಬಹುದೆಂದು ಸಹ

463
00:28:25,000 --> 00:28:29,000
ನಾನು ಇನ್ನೂ 0 ಮಾಡಲು ಪಡೆಯಲಿದ್ದೇನೆ, ಇದು, <0

464
00:28:29,000 --> 00:28:33,000
ಆದ್ದರಿಂದ ನಾನು ಇಲ್ಲ ಎಂದು IFS ಒಳಗೆ ಪಡೆಯಲಿದ್ದೇನೆ

465
00:28:33,000 --> 00:28:38,000
ನಾನು ಈಗಾಗಲೇ ಈ ಪರಿಸ್ಥಿತಿಗಳ ಯಾವುದೇ ಪೂರೈಸಲು ಹೋಗುತ್ತಿಲ್ಲ ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ.

466
00:28:38,000 --> 00:28:41,000
ನಾನು ಹೇಳಿಕೆಯನ್ನು ಬೇರೆ, ಬೇರೆ ವೇಳೆ, ನೀವು ಬಳಸಬಹುದು.

467
00:28:41,000 --> 00:28:45,000
X = 0 ನಾನು ಧನಾತ್ಮಕ ಮುದ್ರಿಸಲು ಅದು ಮೂಲಭೂತವಾಗಿ ಹೇಳುತ್ತದೆ.

468
00:28:45,000 --> 00:28:48,000
ಇದು ಅಲ್ಲ ವೇಳೆ, ನಾನು ಈ ಪರೀಕ್ಷಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ.

469
00:28:48,000 --> 00:28:51,000
ಇದನ್ನು 2 ರ ವೇಳೆ ನಾನು ಇದನ್ನು ಮಾಡಲು ನನಗೆ ಸಾಧ್ಯವಿಲ್ಲ.

470
00:28:51,000 --> 00:28:54,000
ನಾನು X = 2 ಹೊಂದಿದ್ದರೆ ಮೂಲತಃ ನೀವು ಹೇಳಬಹುದು

471
00:28:54,000 --> 00:28:57,000
(X> 0) ವೇಳೆ, ಹೌದು, ಈ ಮುದ್ರಿಸಿ.

472
00:28:57,000 --> 00:29:00,000
ಈಗ ನಾನು> 0 ಗೊತ್ತಾಯಿತು ಎಂದು ಮತ್ತು ಅದು ಮೊದಲ ವೇಳೆ ತೃಪ್ತಿ

473
00:29:00,000 --> 00:29:02,000
ನಾನು ಈ ಕೋಡ್ ರನ್ ಹೋಗಿ ಇಲ್ಲ.

474
00:29:02,000 --> 00:29:09,000
ಈ ಬಳಸುತ್ತಿದ್ದರೆ ಕೋಡ್ 3 ಪಟ್ಟು ವೇಗವಾಗಿ, ವಾಸ್ತವವಾಗಿ, ವೇಗವಾಗಿ ಚಲಿಸುತ್ತದೆ.

475
00:29:09,000 --> 00:29:11,000
ನಾವು ಸುಮಾರು ಮತ್ತು ಮತ್ತು ಅಥವಾ ಕಲಿತರು.

476
00:29:11,000 --> 00:29:15,000
ನಾನು Lexi ಈಗಾಗಲೇ ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಏಕೆಂದರೆ ಈ ಮೂಲಕ ಹೋಗುತ್ತಿದ್ದೇವೆ ಇಲ್ಲ.

477
00:29:15,000 --> 00:29:17,000
| ಆಯೋಜಕರು | ಅದು && ಮತ್ತು ಇಲ್ಲಿದೆ.

478
00:29:17,000 --> 00:29:21,000
>> ನಾನು ಹೇಳುತ್ತೇನೆ ಮಾತ್ರ ವಿಷಯ ನೀವು 3 ಪರಿಸ್ಥಿತಿಯ ಎಚ್ಚರಿಕೆಯಿಂದಿರಿ ಹೊಂದಿದೆ.

479
00:29:21,000 --> 00:29:24,000
ಇದು ತುಂಬಾ ಗೊಂದಲಮಯ ಏಕೆಂದರೆ ನೀವು ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುವಾಗ ಆವರಣ ಬಳಸಿ

480
00:29:24,000 --> 00:29:27,000
ಮತ್ತು ಇನ್ನೊಂದು ಒಂದು ಅಥವಾ ಮತ್ತೊಂದು.

481
00:29:27,000 --> 00:29:30,000
ನಿಮ್ಮ ಪರಿಸ್ಥಿತಿಗಳು ಅರ್ಥ ಖಚಿತವಾಗಿ ಎಂದು ಆವರಣ ಬಳಸಿ

482
00:29:30,000 --> 00:29:34,000
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಕಲ್ಪನೆಯ ಏಕೆಂದರೆ

483
00:29:34,000 --> 00:29:38,000
ಇದು ಮೊದಲ ಸ್ಥಿತಿಗೆ ಮತ್ತು ಒಂದು ಅಥವಾ ಇತರ ಆಗಿರಬಹುದು

484
00:29:38,000 --> 00:29:41,000
ಅಥವಾ 2 ಒಂದು ಸಂಯೋಜಿಸಲ್ಪಟ್ಟಿವೆ ಪರಿಸ್ಥಿತಿಗಳು ಮತ್ತು

485
00:29:41,000 --> 00:29:45,000
ಅಥವಾ ಮೂರನೇ ಒಂದು, ಆದ್ದರಿಂದ ಕೇವಲ ಜಾಗರೂಕರಾಗಿರಿ.

486
00:29:45,000 --> 00:29:48,000
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಾವು ಸ್ವಿಚ್ಗಳು ಬಗ್ಗೆ ಮಾತನಾಡಿದರು.

487
00:29:48,000 --> 00:29:53,000
ನೀವು ವೇರಿಯಬಲ್ ಹೊಂದಿವೆ ಒಂದು ಸ್ವಿಚ್ ಬಹಳ ಉಪಯುಕ್ತವಾಗಿದೆ.

488
00:29:53,000 --> 00:29:55,000
ಲೆಟ್ಸ್ ನೀವು N ಒಂದು ವೇರಿಯೇಬಲ್ ಹೇಳುವುದು

489
00:29:55,000 --> 00:29:59,000
ಆ 0, 1, ಅಥವಾ 2 ಮಾಡಬಹುದು, ಮತ್ತು ಆ ಪ್ರಕರಣಗಳು ಪ್ರತಿ

490
00:29:59,000 --> 00:30:01,000
ನೀವು ಕೆಲಸ ಮಾಡಲು ನೀನು.

491
00:30:01,000 --> 00:30:04,000
ನೀವು ವೇರಿಯಬಲ್ ಬದಲಾಯಿಸಲು ಹೇಳಬಹುದು, ಮತ್ತು ಇದು ಸೂಚಿಸುತ್ತದೆ

492
00:30:04,000 --> 00:30:08,000
ಮೌಲ್ಯದ ನಂತರ, ಮೌಲ್ಯ 1 ನಂತಹ ನಾನು ಹಾಗೆ ಹೋಗುವ ನನಗೆ

493
00:30:08,000 --> 00:30:12,000
ಮತ್ತು ನಂತರ ನಾನು ಬ್ರೇಕ್, ಇದು ನಾನು ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾವುದೇ ನೋಡಲು ಹೋಗುವ ಇಲ್ಲ ಅರ್ಥ

494
00:30:12,000 --> 00:30:15,000
ನಾವು ಈಗಾಗಲೇ ಕೇಸ್ ತೃಪ್ತಿ ಏಕೆಂದರೆ

495
00:30:15,000 --> 00:30:20,000
ತದನಂತರ VALUE2 ಹೀಗೆ, ಮತ್ತು ನಾನು ಒಂದು ಡೀಫಾಲ್ಟ್ ಸ್ವಿಚ್ ಹೊಂದಬಹುದು.

496
00:30:20,000 --> 00:30:24,000
ನಾನು ಹೊಂದಿದ್ದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಯಾವುದೇ ಪದಗಳನ್ನು ಇದ್ದಲ್ಲಿ ಅರ್ಥ

497
00:30:24,000 --> 00:30:29,000
ನಾನು ಬೇರೇನಾದರೂ ಮಾಡುವಂತೆ ಪಡೆಯಲಿದ್ದೇನೆ, ಆದರೆ ಐಚ್ಛಿಕ ಎಂದು.

498
00:30:29,000 --> 00:30:36,000
ನನಗೆ ಎಲ್ಲಾ ಆ. ಈಗ ಟಾಮಿ ಹೊಂದಿವೆ ಅವಕಾಶ.

499
00:30:36,000 --> 00:30:41,000
ಸರಿ, ಈ ವಾರ 3 ರೀತಿಯಲ್ಲಿ ಎಂದು ಹೋಗುತ್ತದೆ.

500
00:30:41,000 --> 00:30:45,000
ಈ ನಾವು, ಎಟ್ ಇತ್ಯಾದಿ ಕ್ರಿಪ್ಟೋ, ವ್ಯಾಪ್ತಿ, ಸಾಲುಗಳು, ಕವರಿಂಗ್ ಪಡೆದುಕೊಳ್ಳುತ್ತೀರಿ ವಿಷಯಗಳ ಕೆಲವು.

501
00:30:45,000 --> 00:30:49,000
ಕ್ರಿಪ್ಟೋ ಮೇಲೆ ಕೇವಲ ಒಂದು ತ್ವರಿತ ಪದ. ನಾವು ಈ ಮನೆ ಬಡಿಯಲು ಹೋಗುತ್ತಿಲ್ಲ.

502
00:30:49,000 --> 00:30:52,000
>> ನಾವು pset 2 ಈ ಆದರೆ ರಸಪ್ರಶ್ನೆ ನೀವು ವ್ಯತ್ಯಾಸವನ್ನು ತಿಳಿಯಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ

503
00:30:52,000 --> 00:30:54,000
ಸೀಸರ್ ಸೈಫರ್ ಮತ್ತು Vigenère ಸೈಫರ್ ನಡುವೆ,

504
00:30:54,000 --> 00:30:57,000
ಆ ಸೈಫರ್ಗಳು ಕೆಲಸ ಎರಡೂ ಮತ್ತು ಅದರ ಗೂಢಲಿಪೀಕರಿಸಲು ರೀತಿಯಲ್ಲಿ ಹೇಗೆ

505
00:30:57,000 --> 00:30:59,000
ಆ 2 ಸೈಫರ್ಗಳು ಬಳಸಿಕೊಂಡು ಡೀಕ್ರಿಪ್ಟ್ ಪಠ್ಯ.

506
00:30:59,000 --> 00:31:03,000
ನೆನಪಿಡಿ, ಸೀಸರ್ ಸೈಫರ್ ಸರಳವಾಗಿ, ಅದೇ ಪ್ರಮಾಣದ ಪ್ರತಿ ಪಾತ್ರದ ತಿರುಗುತ್ತಿದೆ

507
00:31:03,000 --> 00:31:06,000
ವರ್ಣಮಾಲೆಯ ಅಕ್ಷರಗಳನ್ನು ಸಂಖ್ಯೆಯಿಂದ ನೀವು ಮಾಡ್ ದೃಢಪಡಿಸಿಕೊಳ್ಳಬೇಕು.

508
00:31:06,000 --> 00:31:09,000
ಮತ್ತು Vigenère ಸೈಫರ್, ಇನ್ನೊಂದೆಡೆ, ಪ್ರತಿ ಪಾತ್ರದ ತಿರುಗುತ್ತಿದೆ

509
00:31:09,000 --> 00:31:12,000
ಬೇರೆ ಪ್ರಮಾಣದ ಮೂಲಕ, ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಹೇಳುವ ಹೆಚ್ಚು

510
00:31:12,000 --> 00:31:15,000
3 Vigenère ಪ್ರತಿ ಪಾತ್ರದ ಸುತ್ತುವ ಪ್ರತಿ ಪಾತ್ರದ ತಿರುಗಿಸಲು ಕಾಣಿಸುತ್ತದೆ

511
00:31:15,000 --> 00:31:17,000
ಕೆಲವು ಕೀವರ್ಡ್ ಆಧಾರದ ಮೇಲೆ ವಿವಿಧ ಪ್ರಮಾಣದ ಮೂಲಕ

512
00:31:17,000 --> 00:31:20,000
ಕೀವರ್ಡ್ ಪ್ರತಿಯೊಂದು ಅಕ್ಷರದ ಕೆಲವು ವಿಭಿನ್ನ ಪ್ರಮಾಣವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ

513
00:31:20,000 --> 00:31:26,000
ಅದಕ್ಕೆ ಸ್ಪಷ್ಟ ಪಠ್ಯ ತಿರುಗಿಸಲು.

514
00:31:26,000 --> 00:31:28,000
ವೇರಿಯಬಲ್ ವ್ಯಾಪ್ತಿ ಬಗ್ಗೆ ಮೊದಲ ಚರ್ಚೆ ಮಾಡೋಣ.

515
00:31:28,000 --> 00:31:30,000
ಅಸ್ಥಿರ 2 ವಿವಿಧ ವಿಧಗಳಿವೆ.

516
00:31:30,000 --> 00:31:33,000
ನಾವು ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಹೊಂದಿವೆ, ಮತ್ತು ಈ ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಹೋಗುವ

517
00:31:33,000 --> 00:31:36,000
ಹೊರಗೆ ಪ್ರಮುಖ ಅಥವಾ ಯಾವುದೇ ಕ್ರಿಯೆ ಅಥವಾ ಬ್ಲಾಕ್ ಹೊರಗೆ,

518
00:31:36,000 --> 00:31:39,000
ಮತ್ತು ಈ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಗರದಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು.

519
00:31:39,000 --> 00:31:41,000
ನೀವು ಒಂದು ಫಂಕ್ಷನ್ ಮತ್ತು ಕಾರ್ಯದಲ್ಲಿ ಸ್ವಲ್ಪ ಲೂಪ್ ವೇಳೆ

520
00:31:41,000 --> 00:31:44,000
ದೊಡ್ಡ ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಎಲ್ಲೆಡೆ ಪ್ರವೇಶಿಸಬಹುದು.

521
00:31:44,000 --> 00:31:48,000
ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಮತ್ತೊಂದೆಡೆ, ಅದನ್ನು ಅಲ್ಲಿ ಸ್ಥಳಕ್ಕೆ ಕ್ಷೇತ್ರ ಆಗಿದೆ.

522
00:31:48,000 --> 00:31:53,000
>> ನೀವು ಇಲ್ಲಿ ಒಂದು ಫಂಕ್ಷನ್ ವೇಳೆ, ಉದಾಹರಣೆಗೆ, ನಾವು, ಈ ಫಂಕ್ಷನ್ g ಹೊಂದಿವೆ

523
00:31:53,000 --> 00:31:56,000
ಮತ್ತು ಜಿ ಒಳಗೆ ವೈ ಎಂದು ಇಲ್ಲಿ ವೇರಿಯಬಲ್, ಇಲ್ಲ

524
00:31:56,000 --> 00:31:58,000
ಮತ್ತು ಈ ಒಂದು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ಎಂದರ್ಥ.

525
00:31:58,000 --> 00:32:00,000
ಈ ವೇರಿಯಬಲ್ ವೈ ಕರೆಯಲಾಗುತ್ತದೆ ಸಹ

526
00:32:00,000 --> 00:32:03,000
ಮತ್ತು ಈ ವೇರಿಯಬಲ್ ಈ 2 ಕಾರ್ಯಗಳನ್ನು Y ಕರೆಯಲಾಗುತ್ತದೆ

527
00:32:03,000 --> 00:32:06,000
ಪರಸ್ಪರರ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಯಾವ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

528
00:32:06,000 --> 00:32:10,000
ಮತ್ತೊಂದೆಡೆ, ಅಪ್ ಇಲ್ಲಿ ನಾವು, ಇಂಟ್ X = 5 ಸೇ

529
00:32:10,000 --> 00:32:12,000
ಈ ಯಾವುದೇ ಕಾರ್ಯ ವ್ಯಾಪ್ತಿಯ ಹೊರಗಿದೆ.

530
00:32:12,000 --> 00:32:16,000
ಇದು ಮುಖ್ಯ ವ್ಯಾಪ್ತಿಯ ಹೊರಗೆ, ಆದ್ದರಿಂದ ಈ ಒಂದು ಜಾಗತಿಕ ಅಸ್ಥಿರವಾಗಿದೆ.

531
00:32:16,000 --> 00:32:20,000
ಅಥವಾ X + + - ನಾನು X ಹೇಳಬೇಕಾದಾಗ ಈ 2 ಕಾರ್ಯಗಳನ್ನು ಎಂದು ಒಳಗೆ ಅರ್ಥ

532
00:32:20,000 --> 00:32:26,000
ನಾನು ಈ Y ಮತ್ತು ಈ ವೈ ವಿವಿಧ ಚರಗಳಾಗಿವೆ ಬಗೆಗಿನ ಒಂದೇ X ಪ್ರವೇಶಿಸುವ ನುಡಿದರು.

533
00:32:26,000 --> 00:32:30,000
ಜಾಗತಿಕ ವೇರಿಯಬಲ್ ಮತ್ತು ಸ್ಥಳೀಯ ವೇರಿಯಬಲ್ ನಡುವೆ ವ್ಯತ್ಯಾಸವನ್ನು ಆ.

534
00:32:30,000 --> 00:32:33,000
ದೂರದ ವಿನ್ಯಾಸ ಸಂಬಂಧಿಸಿದಂತೆ ಕೆಲವೊಮ್ಮೆ ಇದು ಬಹುಶಃ ಒಂದು ಉತ್ತಮ ಉಪಾಯ

535
00:32:33,000 --> 00:32:37,000
ನೀವು ಬಹುಶಃ ಮಾಡಬಹುದು ಬಂದಾಗಲೆಲ್ಲಾ ಅಸ್ಥಿರ ಸ್ಥಳೀಯ ಇರಿಸಿಕೊಳ್ಳಲು

536
00:32:37,000 --> 00:32:39,000
ಹೊಂದಿರುವ ರಿಂದ ಜಾಗತಿಕ ಅಸ್ಥಿರತೆಗಳ ಒಂದು ಗುಂಪೇ ನಿಜವಾಗಿಯೂ ಗೊಂದಲಮಯ ಪಡೆಯುವುದು.

537
00:32:39,000 --> 00:32:42,000
ನೀವು ಕಾರ್ಯಗಳನ್ನು ಒಂದು ಗುಂಪೇ ಇದ್ದರೆ ಎಲ್ಲವೂ ಒಂದೇ ಮಾರ್ಪಡಿಸುವ

538
00:32:42,000 --> 00:32:45,000
ಈ ಕಾರ್ಯವನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಈ ಜಾಗತಿಕ ಮಾರ್ಪಡಿಸುವ ಹೀಗಾದರೆ ನೀವು ಮರೆತರೆ ಇರಬಹುದು

539
00:32:45,000 --> 00:32:47,000
ಮತ್ತು ಈ ಇತರ ಕಾರ್ಯ, ಅದರ ಬಗ್ಗೆ ಗೊತ್ತಿಲ್ಲ

540
00:32:47,000 --> 00:32:50,000
ನೀವು ಹೆಚ್ಚು ಕೋಡ್ ಪಡೆಯಲು ಮತ್ತು ಇದು ಬಹಳ ಗೊಂದಲಮಯವಾಗಿ ಪಡೆಯಲು ಇಲ್ಲ.

541
00:32:50,000 --> 00:32:53,000
ನೀವು ಬಹುಶಃ ಮಾಡಬಹುದು ಬಂದಾಗಲೆಲ್ಲಾ ಅಸ್ಥಿರ ಸ್ಥಳೀಯ ಕೀಪಿಂಗ್

542
00:32:53,000 --> 00:32:56,000
ಕೇವಲ ಉತ್ತಮ ವಿನ್ಯಾಸ ಹೊಂದಿದೆ.

543
00:32:56,000 --> 00:33:00,000
ರಚನೆಗಳು, ನೆನಪಿಡಿ, ಕೇವಲ ಒಂದೇ ರೀತಿಯ ಅಂಶಗಳನ್ನು ಪಟ್ಟಿಗಳು.

544
00:33:00,000 --> 00:33:04,000
CI ಒಳಗೆ ಹಲೋ, 1, 2.0 ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿರುತ್ತವೆ.

545
00:33:04,000 --> 00:33:06,000
ನಾವು ಹಾಗೆ ಮಾಡಬಹುದು.

546
00:33:06,000 --> 00:33:11,000
>> ನಾವು ಸಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದ ಸಂದರ್ಭದಲ್ಲಿ ಅಂಶಗಳನ್ನು ಒಂದೇ ರೀತಿಯ ಇರಬೇಕು.

547
00:33:11,000 --> 00:33:14,000
ಇಲ್ಲಿ ನಾನು 3 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಸರಣಿ.

548
00:33:14,000 --> 00:33:18,000
ಇಲ್ಲಿ ನಾನು ರಚನೆಯ ಉದ್ದವನ್ನು ಹೊಂದಿದ್ದರೆ, ಆದರೆ ನಾನು ಈ ವಾಕ್ಯ ಅದನ್ನು ಘೋಷಿಸುವ ಭಾವಿಸುತ್ತೇನೆ ವೇಳೆ

549
00:33:18,000 --> 00:33:21,000
ನಾನು ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ನಾನು ತಾಂತ್ರಿಕವಾಗಿ ಈ 3 ಅಗತ್ಯವಿಲ್ಲ ಎಂಬುದನ್ನು ಸೂಚಿಸಲು ಅಲ್ಲಿ.

550
00:33:21,000 --> 00:33:25,000
ಕಂಪೈಲರ್ ರಚನೆಯ ಎಷ್ಟು ದೊಡ್ಡ ವ್ಯಕ್ತಿಯು ಸಾಕಷ್ಟು ಸ್ಮಾರ್ಟ್ ಆಗಿದೆ.

551
00:33:25,000 --> 00:33:28,000
ಈಗ ನಾನು ರಚನೆಯ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಅಥವಾ ಹೊಂದಿಸಲು ಬಯಸಿದಾಗ

552
00:33:28,000 --> 00:33:30,000
ಈ ಮಾಡಲು ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೊಂದಿದೆ.

553
00:33:30,000 --> 00:33:33,000
, ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಏಕೆಂದರೆ ವಾಸ್ತವವಾಗಿ ರಚನೆಯ ಎರಡನೆಯ ಅಂಶ ಮಾರ್ಪಡಿಸಿ ಕಾಣಿಸುತ್ತದೆ,

554
00:33:33,000 --> 00:33:36,000
ಸಂಖ್ಯಾ 1 ಅಲ್ಲ, 0 ಆರಂಭಗೊಂಡು.

555
00:33:36,000 --> 00:33:42,000
ನಾನು ಮೌಲ್ಯ ಓದಲು ಬಯಸಿದರೆ ನಾನು ಸ್ವಲ್ಪ ಹೇಳಬಹುದು ಇಂಟ್ X = ರಚನೆಯ [1].

556
00:33:42,000 --> 00:33:44,000
ನಾನು ಮೌಲ್ಯವನ್ನು ನೀವು ಅಥವಾ ನಾನು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವೆ

557
00:33:44,000 --> 00:33:47,000
ನಾನು ರಚನೆಯ [1] ಹೇಳಬಹುದು = 4.

558
00:33:47,000 --> 00:33:50,000
ತಮ್ಮ ಸೂಚ್ಯಂಕ ಧಾತುಗಳ ಪ್ರವೇಶಿಸುವಾಗ ಆ

559
00:33:50,000 --> 00:33:52,000
ಅಥವಾ ತಮ್ಮ ಸ್ಥಾನಕ್ಕೆ ಅಥವಾ ಅಲ್ಲಿ ಅವರು ಶ್ರೇಣಿಯನ್ನು ನಲ್ಲಿ,

560
00:33:52,000 --> 00:33:57,000
ಮತ್ತು ಪಟ್ಟಿಗಳನ್ನು 0 ಆರಂಭಗೊಂಡು.

561
00:33:57,000 --> 00:34:00,000
ನಾವು, ಆಯ್ರೆಗಳ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ

562
00:34:00,000 --> 00:34:03,000
ಮತ್ತು ಈ ಒಂದು ಬಹು ಆಯಾಮದ ರಚನೆಯ ಕರೆಯಲಾಗುತ್ತದೆ.

563
00:34:03,000 --> 00:34:05,000
ನಾವು ಬಹು ಆಯಾಮದ ರಚನೆಯ ಹೊಂದಿರುವಾಗ

564
00:34:05,000 --> 00:34:07,000
ನಾವು, ಸಾಲುಗಳನ್ನು ಮತ್ತು ಕಾಲಮ್ಗಳನ್ನು ರೀತಿಯ ಹೊಂದಬಹುದು ಅರ್ಥ

565
00:34:07,000 --> 00:34:11,000
ಮತ್ತು ಈ ಆಚರಣಕಾರರು ಅಥವಾ ವಿಚಾರ ಕೇವಲ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

566
00:34:11,000 --> 00:34:14,000
ನಾನು ಬಹು ಆಯಾಮದ ಸರಣಿ ಆ ನಾನು ಅಗತ್ಯವಿಲ್ಲದೇ ಆರಂಭಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ ಅರ್ಥ

567
00:34:14,000 --> 00:34:17,000
ಹೆಚ್ಚು 1 ಸೂಚ್ಯಂಕ ಏಕೆಂದರೆ ನಾನು ಗ್ರಿಡ್ ಹೊಂದಿದ್ದರೆ

568
00:34:17,000 --> 00:34:19,000
ಕೇವಲ ನೀವು ಏನನ್ನು ಸಾಲು ಹೇಳುವ ನಮಗೆ ಸಂಖ್ಯೆಯನ್ನು ನೀಡುವುದಿಲ್ಲ.

569
00:34:19,000 --> 00:34:22,000
ನಿಜಕ್ಕೂ ಕೇವಲ ನಮಗೆ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡಲು ವಿಶೇಷವೇನು.

570
00:34:22,000 --> 00:34:25,000
ಲೆಟ್ಸ್ ನಾನು ಇಲ್ಲಿ ಈ ಸರಣಿ ಹೇಳುತ್ತಾರೆ.

571
00:34:25,000 --> 00:34:30,000
ನಾನು ಗ್ರಿಡ್ ಎಂಬ ಸರಣಿ, ಮತ್ತು ನಾನು, ಅದು 2 ಸಾಲುಗಳನ್ನು ಮತ್ತು ಕಾಲಮ್ಗಳನ್ನು 3 ಹೇಳುವ ನಾನು

572
00:34:30,000 --> 00:34:32,000
ಮತ್ತು ಆದ್ದರಿಂದ ಇದು ದೃಶ್ಯೀಕರಿಸುವ ಒಂದು ಮಾರ್ಗವಾಗಿದೆ.

573
00:34:32,000 --> 00:34:37,000
ನಾನು [1] ನಲ್ಲಿ ಅಂಶ ಸಿಗತ್ತೆ ಹೇಳುವುದಾದರೆ [2]

574
00:34:37,000 --> 00:34:41,000
ಈ ಸಾಲುಗಳನ್ನು ಮೊದಲ ತದನಂತರ ಕಾಲಮ್ಗಳನ್ನು ಏಕೆಂದರೆ ಅರ್ಥ

575
00:34:41,000 --> 00:34:44,000
ನಾನು 1 ಹೇಳಿದರು ರಿಂದ 1 ಸಾಲನ್ನು ನೆಗೆಯುವುದನ್ನು ಪಡೆಯಲಿದ್ದೇನೆ.

576
00:34:44,000 --> 00:34:49,000
>> ನಂತರ ನಾನು ಕಾಲಮ್ 2 ಇಲ್ಲಿ ಮೇಲೆ ಕರೆದುಕೊಂಡು ಹೋಗುತ್ತಾರೆ, ಮತ್ತು ನಾನು ಮೌಲ್ಯವನ್ನು 6 ಪಡೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ.

577
00:34:49,000 --> 00:34:51,000
ಅರ್ಥ?

578
00:34:51,000 --> 00:34:55,000
ಬಹು ಆಯಾಮದ ಸಾಲುಗಳು, ನೆನಪಿಡಿ, ತಾಂತ್ರಿಕವಾಗಿ ರಚನೆಗಳು ಕೇವಲ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ.

579
00:34:55,000 --> 00:34:57,000
ನಾವು ಆಯ್ರೆಗಳ ಆಯ್ರೆಗಳ ಸರಣಿಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ.

580
00:34:57,000 --> 00:35:00,000
ನಾವು ಹೋಗುವ ಇರಿಸಿಕೊಳ್ಳಬಹುದು, ಆದರೆ ಬಗ್ಗೆ ಯೋಚನೆ ನಿಜವಾಗಿಯೂ ಒಂದು ರೀತಿಯ

581
00:35:00,000 --> 00:35:03,000
ಈ ಔಟ್ ಹಾಕಿತು ಮಾಡಲಾಗುತ್ತಿದೆ ಮತ್ತು ಇಂದಿನ ಹೇಗೆ ದೃಶ್ಯೀಕರಿಸುವುದು ಆಗಿದೆ

582
00:35:03,000 --> 00:35:09,000
ಈ ಗ್ರಿಡ್ನಲ್ಲಿ.

583
00:35:09,000 --> 00:35:12,000
ನಾವು ಕಾರ್ಯಗಳನ್ನು ವ್ಯೂಹ ಹಾದುಹೋದಾಗ, ಅವರು ವರ್ತಿಸುವಂತೆ ನೀನು

584
00:35:12,000 --> 00:35:16,000
ನಾವು ಕಾರ್ಯಗಳನ್ನು ನಿಯಮಿತ ಅಸ್ಥಿರ ಹಾದುಹೋದಾಗ ಭಿನ್ನವಾಗಿ ಸ್ವಲ್ಪ

585
00:35:16,000 --> 00:35:18,000
ಒಂದು ಇಂಟ್ ಅಥವಾ ಒಂದು ಫ್ಲೋಟ್ ಹಾದುಹೋಗುವ ಹಾಗೆ.

586
00:35:18,000 --> 00:35:21,000
ನಾವು ಒಂದು ಇಂಟ್ ಅಥವಾ ಅಕ್ಷರ ಅಥವಾ ಇತರ ಡೇಟಾವನ್ನು ಯಾವುದೇ ರೀತಿಯ ಹಾದುಹೋದಾಗ

587
00:35:21,000 --> 00:35:24,000
ನಾವು ಕಾರ್ಯ ಮಾರ್ಪಡಿಸುವ ವೇಳೆ ಒಂದು ನೋಟ ತೆಗೆದುಕೊಂಡಿತು

588
00:35:24,000 --> 00:35:28,000
ಬದಲಾವಣೆ ಅಪ್ ಪ್ರಸಾರಮಾಡಲು ಹೋಗುತ್ತಿಲ್ಲ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಎಂದು ವೇರಿಯಬಲ್ ಮೌಲ್ಯವನ್ನು

589
00:35:28,000 --> 00:35:32,000
ಕರೆ ಫಂಕ್ಷನ್.

590
00:35:32,000 --> 00:35:35,000
ಸಹಿತ, ಇನ್ನೊಂದೆಡೆ ಆ ಸಂಭವಿಸುತ್ತದೆ.

591
00:35:35,000 --> 00:35:39,000
ನಾನು ಕೆಲವು ಫಂಕ್ಷನ್ ಒಂದು ವ್ಯೂಹದಲ್ಲಿ ರವಾನಿಸಲು ಮತ್ತು ಕಾರ್ಯ, ಕೆಲವು ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸಿದರೆ

592
00:35:39,000 --> 00:35:43,000
ನಾನು ಎಂಬ ಕಾರ್ಯಕ್ಕೆ ಹಿಂದಿರುಗಿ ಬಂದಾಗ

593
00:35:43,000 --> 00:35:47,000
ನನ್ನ ರಚನೆಯ ಈಗ ವಿಭಿನ್ನ ಎಂದು ಹೋಗುವ, ಮತ್ತು ಆ ಶಬ್ದಕೋಶವನ್ನು ಇದೆ

594
00:35:47,000 --> 00:35:50,000
ನಾವು ನಂತರ ನೋಡುತ್ತಾರೆ ಎಂದು ಸಾಲುಗಳು, ಉಲ್ಲೇಖ ಇದನ್ನು ಜಾರಿಗೊಳಿಸಬಹುದು.

595
00:35:50,000 --> 00:35:53,000
ಇದು ಹೇಗೆ ಪಾಯಿಂಟರ್ಸ್ ಕೆಲಸ, ಅಲ್ಲಿ ಈ ಮೂಲ ಡೇಟಾ ಪ್ರಕಾರಗಳು, ಸಂಬಂಧಿಸಿದೆ

596
00:35:53,000 --> 00:35:55,000
ಮತ್ತೊಂದೆಡೆ, ಮೌಲ್ಯದ ರವಾನಿಸಲ್ಪಡುತ್ತದೆ.

597
00:35:55,000 --> 00:35:59,000
>> ನಾವು ಕೆಲವು ಚರಾಂಶದ ನಕಲು ಮತ್ತು ನಂತರ ನಕಲು ಹಾದುಹೋಗುವ ಎಂದು ನಗರದ.

598
00:35:59,000 --> 00:36:01,000
ಇದು ನಾವು ವೇರಿಯಬಲ್ ಜೊತೆಗೆ ಏನು ಅಪ್ರಸ್ತುತವಾಗುತ್ತದೆ.

599
00:36:01,000 --> 00:36:06,000
ಕರೆ ಕಾರ್ಯವನ್ನು ಇದು ಬದಲಾಯಿತು ತಿಳಿದಿರಲಿ ಮಾಡುವುದಿಲ್ಲ.

600
00:36:06,000 --> 00:36:10,000
ಅರೆಸ್ ಆ ನಿಟ್ಟಿನಲ್ಲಿ ವಿವಿಧ ಸ್ವಲ್ಪ ಇರುತ್ತದೆ.

601
00:36:10,000 --> 00:36:13,000
ನಾವು ನೋಡಿದ ಉದಾಹರಣೆಗೆ, ಮುಖ್ಯ ಕೇವಲ ಒಂದು ಕಾರ್ಯ

602
00:36:13,000 --> 00:36:15,000
ಆ 2 ವಾದಗಳಲ್ಲಿನ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

603
00:36:15,000 --> 00:36:20,000
ಮುಖ್ಯ ಕಾರ್ಯ ಮೊದಲ ವಾದವನ್ನು, argc, ಅಥವಾ ವಾದಗಳನ್ನು ಸಂಖ್ಯೆ

604
00:36:20,000 --> 00:36:23,000
ಮತ್ತು ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್, argv ಕರೆಯಲಾಗುತ್ತದೆ

605
00:36:23,000 --> 00:36:27,000
ಮತ್ತು ಆ ಆ ವಾದಗಳಲ್ಲಿ ನಿಜವಾದ ಮೌಲ್ಯಗಳು.

606
00:36:27,000 --> 00:36:30,000
ಲೆಟ್ಸ್, ನಾನು this.c ಎಂಬ ಪ್ರೋಗ್ರಾಂ ಹೇಳುತ್ತಾರೆ

607
00:36:30,000 --> 00:36:34,000
ಮತ್ತು ನಾನು ಈ ಮಾಡಲು ಹೇಳುತ್ತಾರೆ, ಮತ್ತು ನಾನು ಆಜ್ಞಾ ಸಾಲಿನ ಈ ರನ್ ಪಡೆಯಲಿದ್ದೇನೆ.

608
00:36:34,000 --> 00:36:38,000
ಈಗ ನನ್ನ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ ಕೆಲವು ವಾದಗಳನ್ನು ರಲ್ಲಿ ರವಾನಿಸಲು, ಈ ಎಂಬ

609
00:36:38,000 --> 00:36:42,000
ನಾನು ಏನೋ ಹಾಗೆ ಹೇಳಬಹುದು. / ಈ CS 50.

610
00:36:42,000 --> 00:36:45,000
ಈ ನಾವು ಟರ್ಮಿನಲ್ ಪ್ರತಿ ದಿನ ಡೇವಿಡ್ ಮಾಡಲು ಕಲ್ಪನೆ ಏನು.

611
00:36:45,000 --> 00:36:48,000
ಆ ಕಾರ್ಯಕ್ರಮದ ಆದರೆ ಈಗ ಮುಖ್ಯ ಕಾರ್ಯ ಒಳಗೆ

612
00:36:48,000 --> 00:36:52,000
ಈ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ argc 4.

613
00:36:52,000 --> 00:36:56,000
ನಾವು ಮಾತ್ರ CS 50 ರಲ್ಲಿ ಹಾದು ಇರುವ ಕಾರಣ ಇದು ಸ್ವಲ್ಪ ಗೊಂದಲ ಇರಬಹುದು.

614
00:36:56,000 --> 00:36:58,000
ಕೇವಲ 3.

615
00:36:58,000 --> 00:37:02,000
ಆದರೆ ನೆನಪಿಡಿ ಎಂದು argv ಮೊದಲ ಅಂಶ ಅಥವಾ ಮೊದಲ ವಾದವನ್ನು

616
00:37:02,000 --> 00:37:05,000
ಕಾರ್ಯ ಸ್ವತಃ ಹೆಸರು.

617
00:37:05,000 --> 00:37:07,190
ಆದ್ದರಿಂದ, ನಾವು 4 ವಿಷಯಗಳನ್ನು ಅರ್ಥ

618
00:37:07,190 --> 00:37:10,530
ಮತ್ತು ಮೊದಲ ಅಂಶ. / ಈ ಏರಲಿದೆ.

619
00:37:10,530 --> 00:37:12,970
ಮತ್ತು ಈ ಸ್ಟ್ರಿಂಗ್ ನಿರೂಪಿಸಲಾಗಿದೆ ಮಾಡಲಾಗುತ್ತದೆ.

620
00:37:12,970 --> 00:37:18,590
ನಂತರ ಉಳಿದ ಅಂಶಗಳನ್ನು ನಾವು ಕಾರ್ಯಕ್ರಮದ ಹೆಸರು ನಂತರ ಬೆರಳಚ್ಚಿಸಿದ ಯಾವುವು.

621
00:37:18,590 --> 00:37:22,720
ಆದ್ದರಿಂದ ಪಕ್ಕಕ್ಕೆ ಕೇವಲ ಒಂದು, ನಾವು ಬಹುಶಃ pset 2 ರಲ್ಲಿ ಕಂಡಿತು ಎಂದು,

622
00:37:22,720 --> 00:37:28,780
ಸ್ಟ್ರಿಂಗ್ 50 ಪೂರ್ಣಾಂಕ 50 ≠ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

623
00:37:28,780 --> 00:37:32,520
ಆದ್ದರಿಂದ ನಾವು, ಸ್ವಲ್ಪ ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ 'ಇಂಟ್ X = argv 3.'

624
00:37:32,520 --> 00:37:36,470
>> ಈ ಸ್ಟ್ರಿಂಗ್ ಏಕೆಂದರೆ ಕೇವಲ, ಅರ್ಥ ಹಿಂದಿರುಗಬಹುದೆಂದು, ಮತ್ತು ಈ ಒಂದು ಪೂರ್ಣಾಂಕ.

625
00:37:36,470 --> 00:37:38,510
ನೀವು 2 ನಡುವೆ ಬದಲಾಯಿಸಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ನೆನಪಿಡಿ, ನಾವು ನೀನು

626
00:37:38,510 --> 00:37:40,810
atoi ಎಂಬ ಈ ಮ್ಯಾಜಿಕ್ ಫಂಕ್ಷನ್.

627
00:37:40,810 --> 00:37:46,270
ಒಂದು ಸಾಲನ್ನು ತೆಗೆದುಕೊಂಡು ಒಂದು ತಂತುವಿನ ಒಳಗೆ ನಿರೂಪಿಸಲಾಗಿದೆ ಪೂರ್ಣಾಂಕ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

628
00:37:46,270 --> 00:37:48,360
ಆದ್ದರಿಂದ, ರಸಪ್ರಶ್ನೆ ಮೇಲೆ ಮಾಡಲು ಸುಲಭ ತಪ್ಪು ಇಲ್ಲಿದೆ

629
00:37:48,360 --> 00:37:51,590
ಈ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸರಿಯಾದ ರೀತಿಯ ಯೋಚಿಸಿದರು.

630
00:37:51,590 --> 00:37:53,860
ಆದರೆ ಕೇವಲ ಈ ಯಾವಾಗಲೂ ತಂತಿಗಳನ್ನು ಎಂದು ತಿಳಿದಿದೆ

631
00:37:53,860 --> 00:38:00,920
ತಂತಿ ಮಾತ್ರ ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಅಕ್ಷರ ಅಥವಾ ಒಂದು ಫ್ಲೋಟ್ ಹೊಂದಿದೆ ಸಹ.

632
00:38:00,920 --> 00:38:03,380
ಈಗ ಸಮಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

633
00:38:03,380 --> 00:38:06,700
ನಾವು ಎಲ್ಲಾ ಈ ಅಸಾಮಾನ್ಯ ಕೆಲಸಗಳನ್ನು ಎಲ್ಲಾ ಈ ಕ್ರಮಾವಳಿಗಳು ಹೊಂದಿರುವಾಗ,

634
00:38:06,700 --> 00:38:11,580
ಇದು ಪ್ರಶ್ನೆ ಕೇಳಲು ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಆಗುತ್ತದೆ "ಅವರು ಎಷ್ಟು ತೆಗೆದುಕೊಳ್ಳುವಿರಿ?"

635
00:38:11,580 --> 00:38:15,500
ನಾವು ಅಸಂಪಾತ ಸಂಕೇತನ ಕರೆಯುವುದನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.

636
00:38:15,500 --> 00:38:18,430
ಹಾಗೆಯೇ, ನಾವು ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ನೀಡಲು ಹೇಳಲು ಅವಕಾಶ - ಈ ಅರ್ಥ

637
00:38:18,430 --> 00:38:20,840
ಕೆಲವು ನಿಜವಾಗಿಯೂ, ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ ಇನ್ಪುಟ್.

638
00:38:20,840 --> 00:38:23,840
ನಾವು ಪ್ರಶ್ನೆ ಕೇಳಲು ಬಯಸುವ, "ಎಷ್ಟು ತೆಗೆದುಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ?

639
00:38:23,840 --> 00:38:26,370
ಎಷ್ಟು ಹಂತಗಳನ್ನು ಚಲಾಯಿಸಲು ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ

640
00:38:26,370 --> 00:38:29,980
ಇನ್ಪುಟ್ ಗಾತ್ರವು ಕ್ರಿಯೆಯಾಗಿದೆ ಎಂದು? "

641
00:38:29,980 --> 00:38:33,080
ನಾವು ರನ್ ಸಮಯ ವಿವರಿಸಬಹುದು ಮೊದಲ ರೀತಿಯಲ್ಲಿ ದೊಡ್ಡ ಒ ಮೂಲಕ

642
00:38:33,080 --> 00:38:35,380
ಮತ್ತು ಈ ನಮ್ಮ ಕೆಟ್ಟ ಪೆಟ್ಟಿಗೆ ರನ್ನಿಂಗ್ ಸಮಯ.

643
00:38:35,380 --> 00:38:38,590
ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಂಗಡಿಸಲು ಬಯಸುವ ಹಾಗಿದ್ದಲ್ಲಿ, ಮತ್ತು ನಾವು ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನೀಡಿ

644
00:38:38,590 --> 00:38:41,000
ಇದು ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಆಗಿರಬೇಕು ಆ, ಅವರೋಹಣ ಕ್ರಮದಲ್ಲಿ ದ

645
00:38:41,000 --> 00:38:43,130
ಆ ಕೆಟ್ಟ ಕೇಸ್ ಎಂದು ವಿಶೇಷವೇನು.

646
00:38:43,130 --> 00:38:49,800
ಈ ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಸಮಯದಲ್ಲಿ ಗರಿಷ್ಠ ಉದ್ದ ಬೌಂಡ್ ನಮ್ಮ ಮೇಲಿನ ಹೊಂದಿದೆ.

647
00:38:49,800 --> 00:38:54,740
ಮತ್ತೊಂದೆಡೆ, ಈ Ω ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯ ಸಮಯ ವಿವರಿಸಲು ಹೋಗುತ್ತದೆ.

648
00:38:54,740 --> 00:38:58,210
ನಾವು ವಿಂಗಡಿಸುವ ಅಲ್ಗಾರಿದಮ್ ಒಂದು ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ಶ್ರೇಣಿಯನ್ನು ನೀಡುತ್ತದೆ ಹಾಗಾಗಿ,

649
00:38:58,210 --> 00:39:00,940
ಅದನ್ನು ವಿಂಗಡಿಸಲು ಹೇಗೆ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ?

650
00:39:00,940 --> 00:39:06,610
ಮತ್ತು ಈ, ನಂತರ ಸಮಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಒಂದು ಕಡಿಮೆ ಪರಿಮಿತಿಯು ವಿವರಿಸುತ್ತದೆ.

651
00:39:06,610 --> 00:39:10,980
ಇಲ್ಲಿ ಕೆಲವು ಸಾಮಾನ್ಯ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಾರಿ ವಿವರಿಸುವ ಕೆಲವು ಪದಗಳು.

652
00:39:10,980 --> 00:39:13,120
ಈ ಏರಿಕೆಯ ಕ್ರಮದಲ್ಲಿ ಇರುತ್ತದೆ.

653
00:39:13,120 --> 00:39:16,060
ನಾವು ವೇಗದ ಚಾಲನೆಯ ಸಮಯ ಸ್ಥಿರ ಕರೆಯಲಾಗುತ್ತದೆ.

654
00:39:16,060 --> 00:39:19,800
>> ನಮ್ಮ ಅಲ್ಗಾರಿದಮ್ ನೀಡಿ ಎಷ್ಟು ಅಂಶಗಳು ಯಾವುದೇ, ಅರ್ಥ

655
00:39:19,800 --> 00:39:22,280
ನಮ್ಮ ಶ್ರೇಣಿಯನ್ನು ಇದು ವಿಂಗಡಿಸುವ, ಎಷ್ಟು ದೊಡ್ಡದಾಗಿದೆ ಯಾವುದೇ

656
00:39:22,280 --> 00:39:26,510
ಅಥವಾ ನಾವು ಶ್ರೇಣಿಯನ್ನು ಮಾಡುತ್ತಿರುವುದು ಕೆಲಸದಲ್ಲಿರುವಾಗ ಯಾವಾಗಲೂ ಅಷ್ಟೇ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

657
00:39:26,510 --> 00:39:30,270
ನಾವು ಕೇವಲ ಒಂದು ಸ್ಥಿರ ಇದು 1, ಆ ಪ್ರತಿನಿಧಿಸಬಹುದು.

658
00:39:30,270 --> 00:39:32,410
ನಾವು ಲಾಗರಿದಮ್ ರನ್ ಸಮಯದಲ್ಲಿ ನೋಡುತ್ತಿದ್ದರು.

659
00:39:32,410 --> 00:39:34,800
ಆದ್ದರಿಂದ ಬೈನರಿ ಸರ್ಚ್ ಸ್ವಲ್ಪ ಲಾಗರಿದಮ್ ಆಗಿದೆ

660
00:39:34,800 --> 00:39:37,140
ನಾವು ಅರ್ಧ ಪ್ರತಿ ಬಾರಿ ಸಮಸ್ಯೆಯನ್ನು ಕತ್ತರಿಸಿ ಅಲ್ಲಿ

661
00:39:37,140 --> 00:39:40,970
ತದನಂತರ ವಿಷಯಗಳನ್ನು ಕೇವಲ ಅಲ್ಲಿಂದ ಹೆಚ್ಚಿನ ಪಡೆಯಿರಿ.

662
00:39:40,970 --> 00:39:43,580
ಮತ್ತು ನೀವು ಯಾವುದೇ ಅಪವರ್ತನೀಯ ಕ್ರಮಾವಳಿಯ ಒಂದು ಓ ಬರೆಯುವ ಬಳಸುತ್ತಿದ್ದರೆ,

663
00:39:43,580 --> 00:39:47,850
ನೀವು ಬಹುಶಃ ನಿಮ್ಮ ದಿನ ಕೆಲಸ ಈ ಪರಿಗಣಿಸುವುದಿಲ್ಲ ಮಾಡಬೇಕು.

664
00:39:47,850 --> 00:39:53,910
ನಾವು ಚಾಲನೆಯಲ್ಲಿರುವ ಬಾರಿ ಹೋಲಿಸಿ ಅದು ಮನಸ್ಸಿನಲ್ಲಿ ಈ ವಿಷಯಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳಲು ಮುಖ್ಯವಾಗಿರುತ್ತದೆ.

665
00:39:53,910 --> 00:39:57,760
ನಾನು ಒ (N) ಎಂದು ಕ್ರಮಾವಳಿ, ಮತ್ತು ಬೇರೆಯವರು ಹಾಗಾಗಿ

666
00:39:57,760 --> 00:40:03,590
ಓ ಒಂದು ಕ್ರಮಾವಳಿ (2n) ಈ ವಾಸ್ತವವಾಗಿ asymptotically ಸಮಾನ ಹೊಂದಿದೆ.

667
00:40:03,590 --> 00:40:06,590
ನಾವು eleventy ಶತಕೋಟಿ ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆ ಎಂದು n ಇಮ್ಯಾಜಿನ್ ಆದ್ದರಿಂದ:

668
00:40:06,590 --> 00:40:13,090
ಆದ್ದರಿಂದ ನಾವು eleventy ಶತಕೋಟಿ ರೀತಿಯ + 3 eleventy ಶತಕೋಟಿ ಹೋಲಿಕೆ ಮಾಡಿದಾಗ,

669
00:40:13,090 --> 00:40:17,640
ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಆ +3 ನಿಜವಾಗಿಯೂ ಎಂದಿಗೂ ಒಂದು ದೊಡ್ಡ ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡುವುದಿಲ್ಲ.

670
00:40:17,640 --> 00:40:20,980
ನಾವು ಈ ವಿಷಯಗಳನ್ನು ಸಮಾನ ಪರಿಗಣಿಸಿ ಆರಂಭಿಸಲು ನೀನು ಏಕೆ ಆ.

671
00:40:20,980 --> 00:40:24,220
ಇಲ್ಲಿ ಈ ಸ್ಥಿರ ವಿಷಯಗಳನ್ನು ಆದ್ದರಿಂದ,, 2 X ಈ ಸ್, ಅಥವಾ 3 ಸೇರಿಸುವ

672
00:40:24,220 --> 00:40:27,180
ಈ ಕೇವಲ ಸ್ಥಿರಾಂಕಗಳಾಗಿವೆ, ಮತ್ತು ಈ ಅಪ್ ಬಿಡಿ ಹೋಗುವ.

673
00:40:27,180 --> 00:40:32,480
ಈ ರನ್ ಬಾರಿ ಎಲ್ಲಾ 3 ಅವರು ಒ (N) ನೀವು ಹೇಳುವ ಅದೇ ಏಕೆ ಆ ನ.

674
00:40:32,480 --> 00:40:37,490
ನಾವು 2 ಇತರ ರನ್ಟೈಮ್ ಹೊಂದಿದ್ದರೆ ಹಾಗೆಯೇ, ಒ (N ³ + 2n ²) ನಾವು ಸೇರಿಸಬಹುದು ಹೇಳಿ ನೋಡೋಣ

675
00:40:37,490 --> 00:40:42,070
ನಂತರ + N, + 7, ಮತ್ತು ನಾವು ಒ ಎಂದು ಇನ್ನೊಂದು ರನ್ ಸಮಯ (N ³) ಹೊಂದಿರುತ್ತವೆ.

676
00:40:42,070 --> 00:40:46,290
ಈ ಒಂದೇ ಅಲ್ಲ - ಈ ಕಾರಣ ಮತ್ತೆ, ಈ ಒಂದೇ ಆಗಿವೆ.

677
00:40:46,290 --> 00:40:49,840
ಈ ಅದೇ ವಸ್ತುಗಳು, ಕ್ಷಮಿಸಿ. ಆದ್ದರಿಂದ ಈ ಅದೇ ಕಾರಣ

678
00:40:49,840 --> 00:40:53,090
ಈ N ³ ಈ 2n ² ಪ್ರಭಾವ ಹೋಗುತ್ತದೆ.

679
00:40:53,090 --> 00:40:59,130
>> ನಾವು ಒ (N ³) ಮತ್ತು ಓ ನಂತಹ ಬಾರಿ ರನ್ ನೀವು ಏನು ಒಂದೇ ಅಲ್ಲ (N ²)

680
00:40:59,130 --> 00:41:02,820
ಈ N ³ ಈ N ² ಹೆಚ್ಚು ದೊಡ್ಡ ಕಾರಣ.

681
00:41:02,820 --> 00:41:05,470
ನಾವು ಘಾತಾಂಕಗಳ ಹೊಂದಿದ್ದರೆ ಆದ್ದರಿಂದ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಈ, ಪರವಾಗಿಲ್ಲ ಆರಂಭಿಸುತ್ತದೆ

682
00:41:05,470 --> 00:41:08,280
ನಾವು ಇಲ್ಲಿ ಅಪ್ ಆದರೆ ನಾವು, ಅಂಶಗಳು ವ್ಯವಹರಿಸುವಾಗ ಮಾಡಿದಾಗ

683
00:41:08,280 --> 00:41:12,810
ನಂತರ ಅವರು ಕೇವಲ ರೊಳಗಿನ ಹೋಗುವ ಕಾರಣ ಪರವಾಗಿಲ್ಲ ಹಿಂದಿರುಗಬಹುದೆಂದು.

684
00:41:12,810 --> 00:41:16,760
ನಾವು ಇದುವರೆಗೆ ನೋಡಿದ ಕ್ರಮಾವಳಿಗಳ ಕೆಲವು ಅವಲೋಕಿಸೋಣ

685
00:41:16,760 --> 00:41:19,260
ಮತ್ತು ತಮ್ಮ ರನ್ ಆ ಬಗ್ಗೆ ಮಾತನಾಡಲು.

686
00:41:19,260 --> 00:41:23,850
ಒಂದು ಪಟ್ಟಿಯಲ್ಲಿ ಹಲವಾರು ಹುಡುಕುತ್ತಿರುವ ಮೊದಲ ರೀತಿಯಲ್ಲಿ, ನಾವು ನೋಡಿದ, ರೇಖೀಯ ಹುಡುಕಾಟ ಆಗಿತ್ತು.

687
00:41:23,850 --> 00:41:26,950
ಮತ್ತು ರೇಖೀಯ ಹುಡುಕಾಟ ಅನುಷ್ಠಾನಕ್ಕೆ ಸೂಪರ್ ನೇರವಾಗಿರುತ್ತದೆ.

688
00:41:26,950 --> 00:41:30,490
ನಾವು ಕೇವಲ ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದು, ಮತ್ತು ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಅಂಶ ನೋಡಲು ನೀನು

689
00:41:30,490 --> 00:41:34,260
ನಾವು ಸಂಖ್ಯೆಯನ್ನು ಕಂಡು ರವರೆಗೆ ನಾವು ಹುಡುಕುತ್ತಿರುವ.

690
00:41:34,260 --> 00:41:38,370
ಆದ್ದರಿಂದ ಅರ್ಥ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಒ (N).

691
00:41:38,370 --> 00:41:40,860
ಅಂಶ ವೇಳೆ ಇಲ್ಲಿ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಆಗಿರಬಹುದು

692
00:41:40,860 --> 00:41:45,710
ಕೊನೆಯ ಅಂಶ, ನಂತರ ರೇಖೀಯ ಹುಡುಕಾಟ ಬಳಸಿ ನಾವು ಪ್ರತಿಯೊಂದು ಅಂಶ ನೋಡಲು ಹೊಂದಿವೆ

693
00:41:45,710 --> 00:41:50,180
ನಾವು ಅದನ್ನು ಪಟ್ಟಿಯಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಎಂದು ತಿಳಿಯಲು ಕಳೆದ ಒಂದು ಪಡೆಯಲು ತನಕ.

694
00:41:50,180 --> 00:41:52,910
ನಾವು ಅರ್ಧದಾರಿಯಲ್ಲೇ ಕೈಬಿಟ್ಟು ಹೇಳಲು ಸಾಧ್ಯವಿಲ್ಲ, "ಇದು ಪ್ರಾಯಶಃ ಇಲ್ಲಿ ಅಲ್ಲ."

695
00:41:52,910 --> 00:41:55,980
ರೇಖೀಯ ಹುಡುಕಾಟ ನಾವು ಎಲ್ಲಾ ವಿಷಯವನ್ನು ನೋಡಲು ಹೊಂದಿವೆ.

696
00:41:55,980 --> 00:41:59,090
ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯ ಸಮಯ, ಮತ್ತೊಂದೆಡೆ, ಸ್ಥಿರವಾಗಿರುತ್ತದೆ

697
00:41:59,090 --> 00:42:04,200
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಕೇವಲ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ ಒಂದು ಕಾರಣ.

698
00:42:04,200 --> 00:42:08,930
ಆದ್ದರಿಂದ ನಮಗೆ ನಿಖರವಾಗಿ 1 ಹಂತ, ಪಟ್ಟಿಯನ್ನು ಹೇಗೆ ದೊಡ್ಡದಾಗಿದೆ ಯಾವುದೇ ತೆಗೆದುಕೊಳ್ಳುವುದು

699
00:42:08,930 --> 00:42:12,140
ನಾವು ಮೊದಲ ಅಂಶ ಪ್ರತಿ ಬಾರಿ ಹುಡುಕುತ್ತಿರುವ ವೇಳೆ.

700
00:42:12,140 --> 00:42:15,390
>> ಆದ್ದರಿಂದ ನೀವು ಹುಡುಕುತ್ತಿರುವಾಗ, ನೆನಪಿಡಿ, ಇದು ನಮ್ಮ ಪಟ್ಟಿಯಲ್ಲಿ ಬೇರ್ಪಡಿಸಬೇಕು ಎಂದು ಬಯಸುವುದಿಲ್ಲ.

701
00:42:15,390 --> 00:42:19,430
ನಾವು ಸುಮ್ಮನೆ ಪ್ರತಿಯೊಂದು ಅಂಶ ಮೇಲೆ ನೋಡಲು ನೀನು, ಮತ್ತು ನಿಜವಾಗಿ ಮಹತ್ವದ ಕಾರಣ

702
00:42:19,430 --> 00:42:23,560
ಯಾವ ಕ್ರಮದಲ್ಲಿ ಆ ಅಂಶಗಳನ್ನು ಸೈನ್ ಗಳು

703
00:42:23,560 --> 00:42:28,110
ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ ಹುಡುಕಾಟ ಅಲ್ಗಾರಿದಮ್ ಬೈನರಿ ಸರ್ಚ್ ಇಷ್ಟಪಡುವ ಸಂಗತಿಯಾಗಿದೆ.

704
00:42:28,110 --> 00:42:31,500
ನಿಮಗೆ ನೀನು ನೆನಪಿಡಿ, ಬೈನರಿ ಸರ್ಚ್ ಆಫ್ ಅಳವಡಿಕೆಯಾಗಿದ್ದು

705
00:42:31,500 --> 00:42:34,320
ಪಟ್ಟಿಯ ಮಧ್ಯಮ ನೋಡುವುದರಿಂದ ಇರಿಸಿಕೊಳ್ಳಲು.

706
00:42:34,320 --> 00:42:38,000
ನಾವು ಮಧ್ಯಮ ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ ಕಾರಣ, ನಾವು ಪಟ್ಟಿ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ಅನಿವಾರ್ಯವಾಗುತ್ತದೆ

707
00:42:38,000 --> 00:42:40,580
ಅಥವಾ ಬೇರೆ ಮಧ್ಯಮ ಅಲ್ಲಿ ನಾವು ಗೊತ್ತಿಲ್ಲ, ಮತ್ತು ನಾವು ಹೆಚ್ಚು ನೋಡಲು ಹೊಂದಿವೆ

708
00:42:40,580 --> 00:42:44,480
ಖರೀದಿ ಸಂಪೂರ್ಣ ಪಟ್ಟಿ, ಮತ್ತು ಆ ಸಮಯದಲ್ಲಿ ನಾವು ಸಮಯವನ್ನು ವ್ಯರ್ಥ ಮಾಡುತ್ತಿದ್ದೇವೆ.

709
00:42:44,480 --> 00:42:48,480
ನಾವು ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಮತ್ತು ನಾವು ಮಧ್ಯಮ ಹೇಗೆ ಆದ್ದರಿಂದ, ನಾವು ಮಧ್ಯಮ ಹೋಲಿಸಲು ನೀನು

710
00:42:48,480 --> 00:42:51,590
ಅಂಶ ನಾವು ಹುಡುಕುತ್ತಿರುವ.

711
00:42:51,590 --> 00:42:54,640
ತುಂಬಾ ಹೆಚ್ಚು ಇದ್ದರೆ, ಆಗ ನಾವು ಅರ್ಧ ಮರೆಯಬೇಡಿ ಮಾಡಬಹುದು

712
00:42:54,640 --> 00:42:57,810
ನಾವು ತಿಳಿದಿರುವ ಕಾರಣ ನಮ್ಮ ಅಂಶ ಈಗಾಗಲೇ ತುಂಬಾ ವೇಳೆ

713
00:42:57,810 --> 00:43:01,080
ಈ ಅಂಶ ಬಲ ಎಲ್ಲವನ್ನೂ ಕೂಡ ಹೆಚ್ಚಾಗಿದೆ,

714
00:43:01,080 --> 00:43:02,760
ನಾವು ಎಂದಿಗೂ ಅಲ್ಲಿ ನೋಡಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

715
00:43:02,760 --> 00:43:05,430
ಅಲ್ಲಿ ಇನ್ನೊಂದೆಡೆ, ನಮ್ಮ ಅಂಶ ತುಂಬಾ ಕಡಿಮೆ ವೇಳೆ,

716
00:43:05,430 --> 00:43:08,700
ನಾವು, ಆ ಅಂಶ ಎಡ ಎಲ್ಲವನ್ನೂ ಅತೀ ಕಡಿಮೆ ತಿಳಿದಿದೆ

717
00:43:08,700 --> 00:43:11,390
ಆದ್ದರಿಂದ ಎರಡೂ ನಿಜವಾಗಿಯೂ, ಅಲ್ಲಿ ನೋಡಲು ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

718
00:43:11,390 --> 00:43:15,760
ಈ ರೀತಿಯಲ್ಲಿ, ಪಟ್ಟಿಯ ಬಿಂದುವಾಗಿ ಪ್ರತಿ ಹಂತದ ಮತ್ತು ನಾವು ನೋಡಿ ಪ್ರತಿ ಸಮಯ,

719
00:43:15,760 --> 00:43:19,060
ಇದ್ದಕ್ಕಿದ್ದಂತೆ ನಾವು ತಿಳಿದಿರುವ ಕಾರಣ ನಾವು ಅರ್ಧ ನಮ್ಮ ಸಮಸ್ಯೆಯನ್ನು ಕತ್ತರಿಸಲು ನೀನು

720
00:43:19,060 --> 00:43:23,040
ನಾವು ಹುಡುಕುತ್ತಿರುವ ಒಂದು ಎಂದು ಸಂಖ್ಯೆಗಳ ಇಡೀ ಗುಂಪೇ.

721
00:43:23,040 --> 00:43:26,950
>> ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಈ, ಈ ರೀತಿಯ ಕಾತುರದಲ್ಲಿರುತ್ತಿದ್ದರು

722
00:43:26,950 --> 00:43:30,990
ಮತ್ತು ನಾವು, ಅರ್ಧ ಪ್ರತಿಯೊಂದು ಸಮಯದಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು ಕತ್ತರಿಸಿ ನೀವು

723
00:43:30,990 --> 00:43:34,920
ಲಾಗರಿದಮ್ ಗೆ ರೇಖೀಯ ನಮ್ಮ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ರನ್ ಸಮಯ ನೆಗೆತ.

724
00:43:34,920 --> 00:43:39,260
ಆದ್ದರಿಂದ ಇದ್ದಕ್ಕಿದ್ದಂತೆ ನಾವು ಲಾಗಿನ್ ಪಟ್ಟಿಯನ್ನು ಒಂದು ಅಂಶ ಪಡೆಯುವ ಕ್ರಮವನ್ನು.

725
00:43:39,260 --> 00:43:42,460
ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯ ಸಮಯ, ಆದರೂ, ಇನ್ನೂ ಸ್ಥಿರವಾಗಿರುತ್ತದೆ

726
00:43:42,460 --> 00:43:45,180
ಈಗ ಏಕೆಂದರೆ, ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಹೇಳುತ್ತಾರೆ ನೋಡೋಣ

727
00:43:45,180 --> 00:43:48,380
ಮೂಲ ಪಟ್ಟಿಯ ಯಾವಾಗಲೂ ನಿಖರ ಮಧ್ಯಮ.

728
00:43:48,380 --> 00:43:52,080
ಆದ್ದರಿಂದ, ನಾವು ಬಯಸುವ ದೊಡ್ಡ ನಮ್ಮ ಪಟ್ಟಿ ಬೆಳೆಯುತ್ತದೆ, ಆದರೆ ನಾವು ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಮಧ್ಯಭಾಗದಲ್ಲಿ ವೇಳೆ

729
00:43:52,080 --> 00:43:54,910
ಅದು ಮಾತ್ರ ನಮ್ಮನ್ನು 1 ಹಂತದ ತೆಗೆದುಕೊಳ್ಳುವುದು.

730
00:43:54,910 --> 00:44:00,920
ನಾವು ಒ (ಲಾಗ್ N) ಮತ್ತು Ω (1) ಅಥವಾ ನಿರಂತರ ನೀವು ಏಕೆ ಆ ನ.

731
00:44:00,920 --> 00:44:04,510
ನ ವಾಸ್ತವವಾಗಿ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಬೈನರಿ ಸರ್ಚ್ ಔಟ್ ಲೆಟ್.

732
00:44:04,510 --> 00:44:08,020
ಆದ್ದರಿಂದ ನಾವು ಅಂಶ 164 ಹುಡುಕುತ್ತಿರುವ ಹೇಳುವ ಅವಕಾಶ.

733
00:44:08,020 --> 00:44:11,650
ನಾವು ಹೋಗುವ ಮೊದಲನೆಯದಾಗಿ ಈ ಪಟ್ಟಿಯ ಸ್ಥಳವಾಗಿರುವುದರಿಂದ ಕಾಣುವುದು.

734
00:44:11,650 --> 00:44:15,060
ಅದು ಹಾಗೆ, ಕೇಂದ್ರ ಈ 2 ಸಂಖ್ಯೆಗಳ ನಡುವೆ ಬಿದ್ದು ಹೋಗುವ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಸಂಭವಿಸುತ್ತದೆ

735
00:44:15,060 --> 00:44:18,960
ಆದ್ದರಿಂದ, ಕೇಂದ್ರ 2 ಸಂಖ್ಯೆಗಳ ನಡುವೆ ಬೀಳುವ ಪ್ರತಿ ಸಮಯ, ಕೇವಲ ನಿರಂಕುಶವಾಗಿ ಹೇಳಿ ನೋಡೋಣ

736
00:44:18,960 --> 00:44:21,150
ನ ಕೇವಲ ಪೂರ್ತಿಗೊಳಿಸಲು ಅವಕಾಶ.

737
00:44:21,150 --> 00:44:24,330
ನಮಗೆ ಈ ರೀತಿಯಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಹಂತದ ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ.

738
00:44:24,330 --> 00:44:29,040
ಆದ್ದರಿಂದ ನಾವು ಹಿಡಿಯಲು ನೀನು ಮತ್ತು ನಾವು 161 ನಮ್ಮ ಪಟ್ಟಿಯ ಮಧ್ಯಮ ಎಂದು ಹೇಳಲು ನೀನು.

739
00:44:29,040 --> 00:44:34,640
ಆದ್ದರಿಂದ 161 <164, ಮತ್ತು 161 ಎಡ ಪ್ರತಿ ಅಂಶ

740
00:44:34,640 --> 00:44:39,120
ಸಹ <164, ಆದ್ದರಿಂದ ನಾವು ಇದನ್ನು ನಮಗೆ ಸಹಾಯ ಹಿಂದಿರುಗಬಹುದೆಂದು ತಿಳಿದಿದೆ

741
00:44:39,120 --> 00:44:42,690
ನಾವು ಅಲ್ಲಿ ಸಾಧ್ಯವಿಲ್ಲ ಹುಡುಕುತ್ತಿರುವ ಅಂಶ ಏಕೆಂದರೆ ಇಲ್ಲಿ ಮೇಲೆ ಕಾಣುವ ಆರಂಭಿಸಲು.

742
00:44:42,690 --> 00:44:47,060
ಆದ್ದರಿಂದ ನಾವು ಮಾಡಬಹುದು, ನಾವು ಪಟ್ಟಿಯ ಇಡೀ ಎಡ ಅರ್ಧ ಮರೆತುಬಿಡಿ ಆಗಿದೆ

743
00:44:47,060 --> 00:44:51,700
ಈಗ ಕೇವಲ 161 ರಿಂದ ಆಫ್ ಬಲದಿಂದ ಪರಿಗಣಿಸುತ್ತಾರೆ.

744
00:44:51,700 --> 00:44:54,050
>> ಆದ್ದರಿಂದ ಮತ್ತೆ, ಈ ತಲುಪಿ; ನ ಕೇವಲ ಪೂರ್ತಿಗೊಳಿಸಲು ಅವಕಾಶ.

745
00:44:54,050 --> 00:44:56,260
ಈಗ 175 ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ.

746
00:44:56,260 --> 00:44:59,180
ಆದ್ದರಿಂದ ನಾವು, ನಮಗೆ ಇಲ್ಲಿ ಅಥವಾ ಇಲ್ಲಿ ನೋಡುತ್ತಿರುವ ಸಹಾಯ ಹಿಂದಿರುಗಬಹುದೆಂದು ತಿಳಿದಿದೆ

747
00:44:59,180 --> 00:45:06,610
ಆದ್ದರಿಂದ ನಾವು ಆ ಎಸೆದು, ಮತ್ತು ಅಂತಿಮವಾಗಿ ನಾವು 164 ಹಿಟ್ ಮಾಡುತ್ತೇವೆ.

748
00:45:06,610 --> 00:45:10,560
ಬೈನರಿ ಸರ್ಚ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

749
00:45:10,560 --> 00:45:14,180
ಲೆಟ್ಸ್ ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಮೂಲಕ ಶೋಧಿಸುವುದಕ್ಕೆ ತೆರಳಿ

750
00:45:14,180 --> 00:45:17,660
ವಾಸ್ತವವಾಗಿ ಯಾವುದೇ ಕ್ರಮದಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ

751
00:45:17,660 --> 00:45:20,960
ಮತ್ತು ಏರುವ ಆ ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.

752
00:45:20,960 --> 00:45:24,060
ನಾವು ನೋಡಿವೆ ಮೊದಲ ಅಲ್ಗಾರಿದಮ್ ಬಬಲ್ ರೀತಿಯ ಕರೆಯಲಾಯಿತು.

753
00:45:24,060 --> 00:45:27,300
ಈ ನಾವು ನೋಡಿದ ಕ್ರಮಾವಳಿಗಳ ಸರಳ ಎಂದು.

754
00:45:27,300 --> 00:45:32,970
ಬಬಲ್ ರೀತಿಯ, ಪಟ್ಟಿಯಲ್ಲಿ ಒಳಗೆ ಯಾವುದೇ 2 ಅಂಶಗಳನ್ನು ಸ್ಥಳದ ಔಟ್ ಆಗ ಹೇಳುತ್ತಾನೆ

755
00:45:32,970 --> 00:45:36,500
ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆ ಕಡಿಮೆ ಸಂಖ್ಯೆಯ ಎಡಕ್ಕೆ ಇಲ್ಲ ಅರ್ಥ

756
00:45:36,500 --> 00:45:40,190
ಆ ಪಟ್ಟಿಯಲ್ಲಿ ಎಂಬುದನ್ನು ಅರ್ಥ ಏಕೆಂದರೆ ನಾವು, ಅವುಗಳನ್ನು ವಿನಿಮಯ ನೀನು

757
00:45:40,190 --> 00:45:42,860
ಇದು ಮೊದಲು ಹೆಚ್ಚು "ಹೆಚ್ಚು ಪ್ರತಿಗಳ".

758
00:45:42,860 --> 00:45:45,180
ಮತ್ತು ನಾವು ಮತ್ತೆ ಮತ್ತೆ ಮತ್ತೆ ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರೆಸಲು ಹೋಗಿ ಮತ್ತು ನೀವು

759
00:45:45,180 --> 00:45:52,100
ಅಂತಿಮವಾಗಿ ಅಂಶಗಳನ್ನು ತಮ್ಮ ಸರಿಯಾದ ಸ್ಥಳಕ್ಕೆ ಬಬಲ್ ರೀತಿಯ ನಾವು ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ತನಕ.

760
00:45:52,100 --> 00:45:57,230
>> ಈ ರನ್ ಸಮಯ ಒ ಏರಲಿದೆ (N ²). ಏಕೆ?

761
00:45:57,230 --> 00:46:00,370
ಅಲ್ಲದೆ, ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ ಏಕೆಂದರೆ, ನಾವು ಪ್ರತಿ ಅಂಶ ತೆಗೆದುಕೊಳ್ಳುವುದು, ಮತ್ತು ನೀವು

762
00:46:00,370 --> 00:46:04,570
ನಾವು ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿ ಇತರ ಅಂಶ ಅದನ್ನು ಹೋಲಿಸಿ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ನೀನು.

763
00:46:04,570 --> 00:46:08,030
ಆದರೆ ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದು, ಬಬಲ್ ರೀತಿಯ ನ

764
00:46:08,030 --> 00:46:12,230
ಕೇವಲ ಒಮ್ಮೆ ಮೂಲಕ ಹೋಗಲು, ಹೇಳಿ ಹೋಗಿ "ಇಲ್ಲ. ನಾನು ಯಾವುದೇ ವಿನಿಮಯ ಮಾಡಲಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಮುಗಿಸಿದ್ದೇನೆ."

765
00:46:12,230 --> 00:46:17,410
ನಾವು Ω (N) ಒಂದು ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಮಯ.

766
00:46:17,410 --> 00:46:20,680
ನ ಪಟ್ಟಿಯಲ್ಲಿ ಬಬಲ್ ರೀತಿಯ ಔಟ್ ಲೆಟ್.

767
00:46:20,680 --> 00:46:23,560
ಅಥವಾ ಮೊದಲು, ನ ಕೇವಲ ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಕೆಲವು ಸೂಡೊಕೋಡ್ಗಳನ್ನು ನೋಡೋಣ.

768
00:46:23,560 --> 00:46:28,160
ನಾವು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ರಲ್ಲಿ, ಟ್ರ್ಯಾಕ್ ಬಯಸುವ ಹೇಳಲಿಚ್ಚಿಸುತ್ತೇನೆ

769
00:46:28,160 --> 00:46:32,190
ನಾವು ಯಾವುದೇ ಅಂಶಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ ಎಂದು ಅಥವಾ ಟ್ರ್ಯಾಕ್.

770
00:46:32,190 --> 00:46:37,610
ಎಂದು ಕಾರಣ ಆದ್ದರಿಂದ, ನಾವು ಯಾವುದೇ ಅಂಶಗಳನ್ನು ವಿನಿಮಯವಾಗಿದೆ ಮಾಡಿಲ್ಲ ಮಾಡಿದಾಗ ನಿಲ್ಲಿಸಲು ನೀನು.

771
00:46:37,610 --> 00:46:41,980
ಆದ್ದರಿಂದ ನಮ್ಮ ಲೂಪ್ ಆರಂಭದಲ್ಲಿ ನಾವು ಏನು ವಿನಿಮಯವಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ತಪ್ಪು ಎಂದು ಹೇಳುತ್ತೇನೆ.

772
00:46:41,980 --> 00:46:47,170
ಈಗ, ನಾವು ಪಟ್ಟಿ ಮೂಲಕ ಹೋಗಿ ನಾನು ಅಂಶ ನಾನು + 1 ಅಂಶ ಹೋಲಿಸಲು ನೀನು

773
00:46:47,170 --> 00:46:50,310
ಮತ್ತು ಇದು ಒಂದು ದೊಡ್ಡ ಸಂಖ್ಯೆಯ ಒಂದು ಸಣ್ಣ ಸಂಖ್ಯೆಯ ಎಡಕ್ಕೆ ಎಂದು ಸಂದರ್ಭದಲ್ಲಿ,

774
00:46:50,310 --> 00:46:52,310
ನಾವು ಅವುಗಳನ್ನು ವಿನಿಮಯ ನೀನು.

775
00:46:52,310 --> 00:46:54,490
>> ನಂತರ ನಾವು ಒಂದು ಅಂಶ ಬದಲಾಯಿಸಿಕೊಳ್ಳಬಹುದು ಎಂದು ನೆನಪಿಡುವ ನೀನು.

776
00:46:54,490 --> 00:46:58,900
ನಾವು ಪಟ್ಟಿ ಮೂಲಕ ಕನಿಷ್ಠ 1 ಬಾರಿ ಕ್ರಮಿಸಬೇಕಾಗುತ್ತದೆ ಅರ್ಥ

777
00:46:58,900 --> 00:47:02,160
ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯನ್ನು ಈಗಾಗಲೇ ಪ್ರತ್ಯೇಕಿಸಲ್ಪಡುತ್ತವೆ ನಾವು ನಿಲ್ಲಿಸಿದ ಸ್ಥಿತಿಯಲ್ಲಿ ಏಕೆಂದರೆ,

778
00:47:02,160 --> 00:47:04,890
ನಾವು ಯಾವುದೇ ಸ್ವಾಪ್ಸ್ ಮಾಡಿಲ್ಲ ಎಂದರ್ಥ.

779
00:47:04,890 --> 00:47:09,960
ನಮ್ಮ ಪರಿಸ್ಥಿತಿ ಕೆಳಗೆ ಇಲ್ಲಿ ಏಕೆ ಆ ನ 'ಕೆಲವು ಅಂಶಗಳನ್ನು ವಿನಿಮಯವಾಗಿದೆ ಮಾಡಲಾಗಿತ್ತು.'

780
00:47:09,960 --> 00:47:13,720
ಈಗ ಅವರ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ನೋಡೋಣ.

781
00:47:13,720 --> 00:47:16,640
ನಾನು ಪಟ್ಟಿಯನ್ನು 5,0,1,6,4 ಹೊಂದಿರುತ್ತವೆ.

782
00:47:16,640 --> 00:47:19,850
ಬಬಲ್ ರೀತಿಯ ಎಡ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಹೋಲಿಸಲು ವಿಶೇಷವೇನು

783
00:47:19,850 --> 00:47:24,700
ನಾನು ಅಂಶಗಳು, ಆದ್ದರಿಂದ ಅಂಶ 1 ಇದು 0 ಗೆ ನಾನು + 1,.

784
00:47:24,700 --> 00:47:29,020
ಇದು, ಹಾಗೂ 5> 0 ಹೇಳಲು ವಿಶೇಷವೇನು, ಆದರೆ ಇದೀಗ 5 ಎಡಕ್ಕೆ ಆಗಿದೆ

785
00:47:29,020 --> 00:47:32,500
ಆದ್ದರಿಂದ ನಾನು 5 ಮತ್ತು 0 ಸ್ವ್ಯಾಪ್ ಅಗತ್ಯವಿದೆ.

786
00:47:32,500 --> 00:47:35,470
ನಾನು ಅವುಗಳನ್ನು ಸ್ವ್ಯಾಪ್ ಮಾಡಿದಾಗ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ ಈ ವಿಭಿನ್ನ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯುವುದು.

787
00:47:35,470 --> 00:47:38,260
ಈಗ 5> 1, ಆದ್ದರಿಂದ ನಾವು ಅದನ್ನು ಸ್ವ್ಯಾಪ್ ಎಂದು ನೀನು.

788
00:47:38,260 --> 00:47:42,160
5> 6 ಅಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಇಲ್ಲಿ ಏನೂ ಮಾಡಬೇಕಿಲ್ಲ.

789
00:47:42,160 --> 00:47:46,690
ಆದರೆ 6> 4, ಆದ್ದರಿಂದ ನಾವು ಸ್ವ್ಯಾಪ್ ಅಗತ್ಯವಿದೆ.

790
00:47:46,690 --> 00:47:49,740
ಮತ್ತೆ, ನಾವು ಅಂತಿಮವಾಗಿ ತಿಳಿಯಲು ಸಂಪೂರ್ಣ ಪಟ್ಟಿ ಮೂಲಕ ಚಲಿಸಬೇಕಾಗುತ್ತದೆ

791
00:47:49,740 --> 00:47:52,330
ಈ ಕ್ರಮದಲ್ಲಿ ಔಟ್ ಎಂದು; ನಾವು ಅವುಗಳನ್ನು ಸ್ವ್ಯಾಪ್,

792
00:47:52,330 --> 00:47:57,120
ಈ ಹಂತದಲ್ಲಿ ನಾವು ಪಟ್ಟಿ ಮೂಲಕ 1 ಹೆಚ್ಚು ಬಾರಿ ಔಟ್ ಅಗತ್ಯವಿದೆ

793
00:47:57,120 --> 00:48:05,390
ಎಲ್ಲವನ್ನೂ ಅದರ ಸಲುವಾಗಿ, ಮತ್ತು ಈ ಬಬಲ್ ರೀತಿಯ ಗಳಿಸಿದರು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

794
00:48:05,390 --> 00:48:10,720
ಕೆಲವು ಅಂಶಗಳನ್ನು ತೆಗೆದುಕೊಂಡು ವಿಂಗಡಿಸುವ ಒಂದು ವಿಭಿನ್ನ ಕ್ರಮಾವಳಿ ಆಯ್ಕೆ ತೆರನಾದ.

795
00:48:10,720 --> 00:48:15,740
ಆಯ್ಕೆ ರೀತಿಯ ಹಿಂದಿನ ಉದ್ದೇಶ ನಾವು ಪಟ್ಟಿಯ ಸಾರ್ಟೆಡ್ ಭಾಗವನ್ನು ನಿರ್ಮಿಸಲು ನೀನು ಎಂದು

796
00:48:15,740 --> 00:48:18,150
ಒಂದು ಸಮಯದಲ್ಲಿ 1 ಅಂಶ.

797
00:48:18,150 --> 00:48:23,170
>> ಮತ್ತು ನಾವು ಮಾಡಲು ನೀನು ರೀತಿಯಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು ಎಡ ಭಾಗವನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ.

798
00:48:23,170 --> 00:48:27,510
ಮತ್ತು ಮೂಲಭೂತವಾಗಿ, ಪ್ರತಿ - ಪ್ರತಿ ಹಂತದ ಮೇಲೆ, ನಾವು ಬಿಟ್ಟು ಚಿಕ್ಕ ಅಂಶ ತೆಗೆದುಕೊಳ್ಳಲು ನೀನು

799
00:48:27,510 --> 00:48:32,310
ಎಂದು ಇನ್ನೂ ವಿಂಗಡಿಸಲಾದ ಇಲ್ಲ, ಮತ್ತು ನಾವು ವಿಂಗಡಿಸಲಾದ ವಿಭಾಗದಲ್ಲಿ ಅದನ್ನು ಸರಿಸಲು ನೀನು.

800
00:48:32,310 --> 00:48:35,850
ಅಂದರೆ ನಾವು ನಿರಂತರವಾಗಿ ಕನಿಷ್ಠ ಆಯ್ದ ಅಂಶ ಕಂಡುಹಿಡಿಯಬೇಕು

801
00:48:35,850 --> 00:48:40,720
ಮತ್ತು ನಂತರ ಕನಿಷ್ಠ ಅಂಶ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಮತ್ತು ಯಾವುದೇ ಅದನ್ನು ಸ್ವ್ಯಾಪ್

802
00:48:40,720 --> 00:48:45,090
ಅತ್ಯಂತ ಎಡಬದಿಯ ಅಂಶ ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು.

803
00:48:45,090 --> 00:48:50,890
ಈ ರನ್ ಸಮಯ ಒ ಏರಲಿದೆ (N ²) ಏಕೆಂದರೆ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ

804
00:48:50,890 --> 00:48:55,070
ನಾವು ಪ್ರತಿ ಇತರ ಅಂಶ ಪ್ರತಿ ಏಕ ಅಂಶ ಹೋಲಿಸಿ ಅಗತ್ಯವಿದೆ.

805
00:48:55,070 --> 00:48:59,250
ನಾವು ಪಟ್ಟಿ ಎಡ ಅರ್ಧ ಆರಂಭವಾಗುವುದು ವೇಳೆ, ನಾವು ಅಗತ್ಯವಿದೆ ಎಂದು ಹೇಳುವ ಕಾರಣ

806
00:48:59,250 --> 00:49:02,970
ಚಿಕ್ಕ ಅಂಶ ಪಡೆಯುವ ಸಂಪೂರ್ಣ ಹಕ್ಕು ವಿಭಾಗದ ಮೂಲಕ ಹೋಗಲು.

807
00:49:02,970 --> 00:49:05,430
ನಂತರ, ಮತ್ತೆ, ನಾವು ಸಂಪೂರ್ಣ ಬಲ ಭಾಗದ ಮೇಲೆ ಹೋಗಿ ಅಗತ್ಯವಿದೆ

808
00:49:05,430 --> 00:49:08,210
ಮತ್ತೆ ಮೇಲೆ ಮತ್ತು ಸುಮಾರು ಕ್ಕಿಂತ ಮುಂದುವರಿಸುವುದಕ್ಕೆ.

809
00:49:08,210 --> 00:49:11,350
ಎಂದು N ² ಎಂದು ವಿಶೇಷವೇನು. ನಾವು ಲೂಪ್ ಮತ್ತೊಂದು ಕುಣಿಕೆಯ ಒಳಗೆ ಅಗತ್ಯವಿದೆ ಎಂದು ನೀನು

810
00:49:11,350 --> 00:49:13,350
ಇದು n ² ಸೂಚಿಸುತ್ತದೆ.

811
00:49:13,350 --> 00:49:16,530
ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ ಚಿಂತನೆಯಲ್ಲಿ, ನ ನಾವು ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡುವುದು ಹೇಳಲು ಅವಕಾಶ;

812
00:49:16,530 --> 00:49:19,270
ನಾವು ವಾಸ್ತವವಾಗಿ N ² ಉತ್ತಮವಾಗಿ ಮಾಡಬೇಡಿ.

813
00:49:19,270 --> 00:49:21,730
ಆಯ್ಕೆ ರೀತಿಯ ಎಂದು ತಿಳಿಯಲು ಯಾವುದೇ ಮಾರ್ಗಗಳಿಲ್ಲ ಏಕೆಂದರೆ

814
00:49:21,730 --> 00:49:25,540
ಕನಿಷ್ಠ ಅಂಶ ನಾನು ನೋಡಿ ಎಂದು ಸಂಭವಿಸಿ ಒಂದಾಗಿದೆ.

815
00:49:25,540 --> 00:49:28,970
ಇದು ಈ ವಾಸ್ತವವಾಗಿ ಕನಿಷ್ಠ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ.

816
00:49:28,970 --> 00:49:31,670
>> ಮತ್ತು ಈ ಅಲ್ಗಾರಿದಮ್ ಬಳಸಿ, ಇದು ಕನಿಷ್ಠ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಮಾತ್ರ ರೀತಿಯಲ್ಲಿ,

817
00:49:31,670 --> 00:49:34,640
ಮತ್ತೆ ಪ್ರತಿಯೊಂದು ಅಂಶ ನೋಡಲು ಹೊಂದಿದೆ.

818
00:49:34,640 --> 00:49:38,420
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ, ನೀವು ಕೊಟ್ಟರೆ - ನೀವು ಆಯ್ಕೆ ವಿಂಗಡಿಸಿ ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಕೊಟ್ಟರೆ,

819
00:49:38,420 --> 00:49:42,720
ಇದು ಇನ್ನೂ ವಿಂಗಡಿಸುತ್ತದೆ ಎಂದು ಒಂದು ಪಟ್ಟಿಯನ್ನು ನೀಡುವ ಉತ್ತಮವಾಗಿ ಮಾಡಲು ಹೋಗಿ ಅಲ್ಲ.

820
00:49:42,720 --> 00:49:46,320
ಇದು ಕೇಸ್ ಎಂದು ಉಂಟಾದರೆ ಮೂಲಕ, ಏನೋ ಒ (ಏನನ್ನಾದರೂ) ಎಂದು

821
00:49:46,320 --> 00:49:50,640
ಮತ್ತು ಏನಾದರೂ ಒಮೆಗಾ, ನಾವು ಹೆಚ್ಚು ಸಂಗ್ರಹವಾಗಿ ಇದು ಏನಾದರೂ θ ಎಂದು ಹೇಳಬಹುದು.

822
00:49:50,640 --> 00:49:52,760
ಆ ನ ಕೇವಲ ಎಂದರೆ ಏನು ಎಂದು, ಎಲ್ಲಿಯಾದರೂ ಅಪ್ ಬಂದು ನೋಡಿ ವೇಳೆ.

823
00:49:52,760 --> 00:49:57,580
>> ಏನೋ N ಆಫ್ ಥೀಟಾ ವೇಳೆ ², ಇದು ದೊಡ್ಡ O (N ²) ಮತ್ತು Ω (N ²) ಆಗಿದೆ.

824
00:49:57,580 --> 00:49:59,790
ಬೆಸ್ಟ್ ಕೇಸ್ ಮತ್ತು ವರ್ಸ್ಟ್ ಕೇಸ್ ಆದ್ದರಿಂದ, ಒಂದು ವ್ಯತ್ಯಾಸವನ್ನು ಮಾಡುವುದಿಲ್ಲ

825
00:49:59,790 --> 00:50:04,400
ಕ್ರಮಾವಳಿ ಒಂದೇ ಪ್ರತಿ ಬಾರಿ ಏನು ಪ್ರಯೋಜನ ಇದೆ.

826
00:50:04,400 --> 00:50:06,610
ಆದ್ದರಿಂದ ಈ ಆಯ್ಕೆಯನ್ನು ರೀತಿಯ ಫಾರ್ ಸೂಡೊಕೋಡ್ಗಳನ್ನು ಕಾಣುತ್ತದೆ ಏನು.

827
00:50:06,610 --> 00:50:10,630
ನಾವು ಮೂಲತಃ ನಾನು ಪಟ್ಟಿಯ ಮೇಲೆ ಮರಳಿ ಬಯಸುವ ಹೇಳಲು ನೀನು

828
00:50:10,630 --> 00:50:15,180
ಬಲಕ್ಕೆ, ಮತ್ತು ಲೂಪ್ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆ ನಲ್ಲಿ ಎಡದಿಂದ, ನಾನು ಸರಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ

829
00:50:15,180 --> 00:50:19,780
ಪಟ್ಟಿಯಲ್ಲಿ ಈ ವಿಂಗಡಿಸಲಾದ ಭಾಗದ ಮೇಲೆ ಕನಿಷ್ಠ ಅಂಶ.

830
00:50:19,780 --> 00:50:23,260
ಮತ್ತು ಒಮ್ಮೆ ನಾನು ಏನಾದರೂ ಸರಿಸಲು, ನಾನು ಮತ್ತೆ ಆ ಅಂಶ ನೋಡಬೇಕು ಎಂದಿಗೂ.

831
00:50:23,260 --> 00:50:28,600
ತಕ್ಷಣ ನಾನು ಪಟ್ಟಿಯನ್ನು ಎಡ ಭಾಗಕ್ಕೆ ಒಂದು ಅಂಶ ಸ್ವ್ಯಾಪ್ ಇದು ವಿಂಗಡಿಸಲಾದ ಏಕೆಂದರೆ

832
00:50:28,600 --> 00:50:32,600
ನಾವು ಕನಿಷ್ಟ ಬಳಸಿಕೊಂಡು ಏರಿಕೆಯ ಕ್ರಮದಲ್ಲಿ ಎಲ್ಲವನ್ನೂ ಮಾಡುತ್ತಿರುವುದು ಕಾರಣ.

833
00:50:32,600 --> 00:50:38,740
ನಾವು ಸರಿ, ನಾವು ಸ್ಥಾನವನ್ನು ಐ ಆರ್, ಮತ್ತು ನಾವು ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ನೋಡಬೇಕು, ಹೇಳಿದರು

834
00:50:38,740 --> 00:50:42,260
ಕನಿಷ್ಠ ಪಡೆಯುವ ಸಲುವಾಗಿ i ನ ಬಲಕ್ಕೆ.

835
00:50:42,260 --> 00:50:46,150
ಆದ್ದರಿಂದ ನಾವು ಪಟ್ಟಿಯ ಕೊನೆಯಲ್ಲಿ ನಾನು + 1 ನೋಡಲು ಬಯಸುವ ಅರ್ಥ.

836
00:50:46,150 --> 00:50:51,610
ಈಗ, ನಾವು ಪ್ರಸ್ತುತ ನಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ ಎಂದು ಅಂಶ, ಇಲ್ಲಿಯವರೆಗೆ ನಮ್ಮ ಕನಿಷ್ಠ ಕಡಿಮೆ ವೇಳೆ

837
00:50:51,610 --> 00:50:54,190
ನೆನಪಿಡಿ, ನಾವು ಎಂದು ಕನಿಷ್ಠ ಪ್ರಾರಂಭ ನೀವು ಇದು,

838
00:50:54,190 --> 00:50:57,020
ಯಾವುದೇ ಅಂಶ ನಾವು ಪ್ರಸ್ತುತ ಆರ್; ನಾನು ಕನಿಷ್ಠ ಎಂದು ಊಹಿಸುತ್ತವೆ ಮಾಡುತ್ತೇವೆ.

839
00:50:57,020 --> 00:51:00,270
ನಾನು ಚಿಕ್ಕದಾಗಿದೆ ಎಂದು ಒಂದು ಅಂಶ ಹುಡುಕಲು ವೇಳೆ, ನಂತರ ನಾನು, ಸರಿ, ಹೇಳಲು ಪಡೆಯಲಿದ್ದೇನೆ

840
00:51:00,270 --> 00:51:02,700
ಜೊತೆಗೆ, ನಾನು ಒಂದು ಹೊಸ ಕನಿಷ್ಠ ಕಂಡುಕೊಂಡಿವೆ.

841
00:51:02,700 --> 00:51:06,080
ನಾನು ಕನಿಷ್ಠ ಆಗಿತ್ತು ಅಲ್ಲಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಲು ಪಡೆಯಲಿದ್ದೇನೆ.

842
00:51:06,080 --> 00:51:09,560
>> ಈಗ, ಒಮ್ಮೆ ನಾನು, ಆ ಹಕ್ಕನ್ನು ಆಯ್ದ ಭಾಗ ಮೂಲಕ ಹೋಗಿದ್ದೀರಿ

843
00:51:09,560 --> 00:51:16,690
ನಾನು ಸ್ಥಾನವನ್ನು ನಾನು ಎಂದು ಅಂಶ ಹೊಂದಿರುವ ಕನಿಷ್ಠ ಅಂಶ ಸ್ವ್ಯಾಪ್ ಪಡೆಯಲಿದ್ದೇನೆ ಹೇಳಬಹುದು.

844
00:51:16,690 --> 00:51:21,100
ನನ್ನ ಪಟ್ಟಿ ನಿರ್ಮಿಸಲು ವಿಶೇಷವೇನು, ಎಡದಿಂದ ಬಲಕ್ಕೆ ಪಟ್ಟಿಯಲ್ಲಿ ನನ್ನ ವಿಂಗಡಿಸಲಾದ ಭಾಗ,

845
00:51:21,100 --> 00:51:25,190
ಮತ್ತು ನಾವು ಆ ಭಾಗದಲ್ಲಿ ಒಮ್ಮೆ ಮತ್ತೆ ಅಂಶ ನೋಡಲು ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

846
00:51:25,190 --> 00:51:27,930
ಒಮ್ಮೆ ನಾವು ಬದಲಾಗಿ ನೀವು.

847
00:51:27,930 --> 00:51:30,260
ಆದ್ದರಿಂದ ಅವರ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಆಯ್ಕೆ ರೀತಿಯ ರನ್ ಅವಕಾಶ.

848
00:51:30,260 --> 00:51:38,220
ಇಲ್ಲಿ ನೀಲಿ ಅಂಶ ನಾನು ಎಂದು ಹೋಗುತ್ತದೆ, ಮತ್ತು ಕೆಂಪು ಅಂಶ ಕನಿಷ್ಠ ಅಂಶ ಎಂದು ಹೋಗುತ್ತದೆ.

849
00:51:38,220 --> 00:51:41,570
ನಾನು 5 ನೇ ಆದ್ದರಿಂದ ಪಟ್ಟಿಯ ಎಡ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ.

850
00:51:41,570 --> 00:51:44,610
ಈಗ ನಾವು ಕನಿಷ್ಠ ಆಯ್ದ ಅಂಶ ಕಂಡುಹಿಡಿಯಬೇಕು.

851
00:51:44,610 --> 00:51:49,480
ನಾವು 0 <5, ಆದ್ದರಿಂದ 0 ನನ್ನ ಹೊಸ ಕನಿಷ್ಠ ಹೇಳುತ್ತಾರೆ.

852
00:51:49,480 --> 00:51:53,820
>> ನಾವು, 0 ಚಿಕ್ಕ ಗುರುತಿಸಲು ಕೂಡ ಏಕೆಂದರೆ ಆದರೆ ನಾನು, ಅಲ್ಲಿ ನಿಲ್ಲಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

853
00:51:53,820 --> 00:51:59,390
ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶ ಮೂಲಕ ಚಲಿಸಬೇಕಾಗುತ್ತದೆ.

854
00:51:59,390 --> 00:52:01,760
, 6 ದೊಡ್ಡದು ದೊಡ್ಡದು 1 ಆದ್ದರಿಂದ, 4 ದೊಡ್ಡದಾಗಿದೆ.

855
00:52:01,760 --> 00:52:05,850
ಈ ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ನೋಡುವ ನಂತರ, ನಾನು 0 ಚಿಕ್ಕ ದೃಢಪಟ್ಟಿದೆ ಎಂದರ್ಥ.

856
00:52:05,850 --> 00:52:09,800
ಹಾಗಾಗಿ 5 ಮತ್ತು 0 ಸ್ವ್ಯಾಪ್ ಪಡೆಯಲಿದ್ದೇನೆ.

857
00:52:09,800 --> 00:52:15,480
ಒಮ್ಮೆ ನಾನು ಸ್ವ್ಯಾಪ್, ನಾನು ಒಂದು ಹೊಸ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ಪಡೆಯಲಿದ್ದೇನೆ, ಮತ್ತು ನಾನು ಮತ್ತೆ ಆ 0 ನೋಡಬೇಕು ಎಂದೂ ತಿಳಿದಿದೆ

858
00:52:15,480 --> 00:52:19,380
ಒಮ್ಮೆ ನಾನು ಬದಲಾಗಿ ನೀವು ಏಕೆಂದರೆ, ನಾನು ಅದನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ ನೀವು ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.

859
00:52:19,380 --> 00:52:22,730
ಈಗ ಅದು ಕೇವಲ ಆದ್ದರಿಂದ, ನೀಲಿ ಅಂಶ ಮತ್ತೆ 5 ಎಂದು ಸಂಭವಿಸುತ್ತದೆ

860
00:52:22,730 --> 00:52:26,030
ಮತ್ತು ನಾವು 1 ನಿರ್ಧರಿಸಲು, 1 ನೋಡಲು 6 ಮತ್ತು 4 ಅಗತ್ಯವಿದೆ

861
00:52:26,030 --> 00:52:31,520
ಚಿಕ್ಕ ಕನಿಷ್ಠ ಅಂಶ, ಆದ್ದರಿಂದ ನಾವು 1 ಮತ್ತು 5 ಸ್ವ್ಯಾಪ್ ಮಾಡುತ್ತೇವೆ.

862
00:52:31,520 --> 00:52:36,890
ಮತ್ತೆ, ನಾವು ನೋಡಬೇಕು - 6 ಮತ್ತು 4 ರಿಂದ 5 ಹೋಲಿಸಿ,

863
00:52:36,890 --> 00:52:39,830
ಮತ್ತು ನಾವು 4 ಮತ್ತು 5 ಸ್ವ್ಯಾಪ್ ಹೋಗುವ, ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಹೋಲಿಸಿ ನೀವು

864
00:52:39,830 --> 00:52:45,740
ಆ 2 ಸಂಖ್ಯೆಗಳು ಮತ್ತು ನಮ್ಮ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪಡೆಯಲು ತನಕ ಅದನ್ನು ಸ್ವ್ಯಾಪ್.

865
00:52:45,740 --> 00:52:49,730
ಆಯ್ಕೆ ರೀತಿಯ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

866
00:52:49,730 --> 00:52:56,420
ಸರಿ. ನ ಇಲ್ಲಿ ಕೊನೆಯ ವಿಷಯಕ್ಕೆ ಚಲಿಸೋಣ, ಮತ್ತು ರಿಕರ್ಶನ್ ಹೊಂದಿದೆ.

867
00:52:56,420 --> 00:52:59,810
>> ಪುನರಾವರ್ತನ, ನೆನಪಿಡಿ, ಈ ನಿಜವಾಗಿಯೂ ಮೆಟಾ ವಿಷಯ ಅಲ್ಲಿ ಒಂದು ಫಂಕ್ಷನ್

868
00:52:59,810 --> 00:53:02,740
ಪದೇಪದೇ ಸ್ವತಃ ಕರೆಗಳನ್ನು.

869
00:53:02,740 --> 00:53:05,620
ಕೆಲವು ಸಮಯದಲ್ಲಿ, ನಮ್ಮ fuction ಪದೇಪದೇ ಸ್ವತಃ ಕರೆ ಆದರೆ,

870
00:53:05,620 --> 00:53:10,100
ನಾವು ಕರೆ ತಡೆಯಲು ಇದು ಕೆಲವು ಪಾಯಿಂಟ್ ಇರಬೇಕು.

871
00:53:10,100 --> 00:53:13,670
ನಾವು ಹಾಗೆ ಮಾಡದಿದ್ದರೆ, ಆಗ ನಾವು ಶಾಶ್ವತವಾಗಿ ಇದನ್ನು ಮುಂದುವರಿಸಲು ನೀನು ಏಕೆಂದರೆ,

872
00:53:13,670 --> 00:53:16,660
ಮತ್ತು ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕೇವಲ ಅಂತ್ಯಗೊಳಿಸಲು ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ.

873
00:53:16,660 --> 00:53:19,200
ಈ ಸ್ಥಿತಿಯನ್ನು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಕರೆ.

874
00:53:19,200 --> 00:53:22,570
ಮತ್ತು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ, ಬದಲಿಗೆ ಮತ್ತೊಮ್ಮೆ ಕಾರ್ಯ ಕರೆ ಹೆಚ್ಚು ಹೇಳುತ್ತಾರೆ

875
00:53:22,570 --> 00:53:25,330
ನಾನು ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಮರಳಿ ಪಡೆಯಲಿದ್ದೇನೆ.

876
00:53:25,330 --> 00:53:28,080
ನಾವು ಮೌಲ್ಯವನ್ನು ಮರಳಿದರು ಒಮ್ಮೆ ಆದ್ದರಿಂದ, ನಾವು ನಾವೇ ಕರೆ ನಿಲ್ಲಿಸಿದ ನಾವು

877
00:53:28,080 --> 00:53:32,550
ಮತ್ತು ನಾವು ಇದುವರೆಗೆ ಮಾಡಿದ ಕರೆಗಳನ್ನು ಉಳಿದ ಸಹ ಮರಳಬಹುದು.

878
00:53:32,550 --> 00:53:36,050
ಮೂಲ ಪ್ರಕರಣದ ವಿರುದ್ಧ ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ.

879
00:53:36,050 --> 00:53:39,050
ಈ ನಾವು ಸೈನ್ ಪ್ರಸ್ತುತ ಎಂಬುದನ್ನು ಕ್ರಿಯೆಯ ಮತ್ತೊಂದು ಕರೆ ಮಾಡಲು ಬಯಸುವ ಆಗ

880
00:53:39,050 --> 00:53:44,690
ಮತ್ತು ನಾವು ಬಹುಶಃ ಯಾವಾಗಲೂ ಆದರೂ, ವಿವಿಧ ವಾದಗಳು ಬಳಸಲು ಬಯಸುವ.

881
00:53:44,690 --> 00:53:48,940
>> ನಾವು ಎಫ್ ಎಂಬ ಫಂಕ್ಷನ್, ಮತ್ತು ಎಫ್ ಕೇವಲ, 1 ಆರ್ಗ್ಯುಮೆಂಟ್ ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಎಂದು ಹಾಗಿದ್ದಲ್ಲಿ

882
00:53:48,940 --> 00:53:52,010
ಮತ್ತು ನಾವು ಕೇವಲ F (1), F (1), F (1) ಕರೆ ಇರಿಸಿಕೊಳ್ಳಲು, ಮತ್ತು ಇದು ಆದ್ದರಿಂದ ಅದು ಸಂಭವಿಸಿದಲ್ಲಿ

883
00:53:52,010 --> 00:53:56,510
ಆರ್ಗ್ಯುಮೆಂಟ್ 1 ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ ಬರುತ್ತಾರೆ, ನಾವು ಇನ್ನೂ ನಿಲ್ಲಿಸಲು ಹೋಗುವ ಎಂದಿಗೂ ನೀವು.

884
00:53:56,510 --> 00:54:01,620
ನಾವು ಒಂದು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿದ್ದರೂ ಸಹ, ನಾವು ಅಂತಿಮವಾಗಿ ನಾವು ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಡೆಯಲು ನೀನು ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ.

885
00:54:01,620 --> 00:54:04,250
ನಾವು ಈ ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ ಉಳಿದರು ಇರಿಸಿಕೊಳ್ಳಲು ಇಲ್ಲ.

886
00:54:04,250 --> 00:54:09,870
ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು ಕರೆ ಮಾಡಿದಾಗ, ನಾವು ಬಹುಶಃ ಬೇರೊಂದು ವಾದವು ಪ್ರತಿ ಸಮಯ ಎಂದು ನೀನು.

887
00:54:09,870 --> 00:54:12,700
ಇಲ್ಲಿ ನಿಜವಾಗಿಯೂ ಸರಳ ಪುನರಾವರ್ತಿತ ಕ್ರಿಯೆಯಾಗಿದೆ.

888
00:54:12,700 --> 00:54:15,090
ಆದ್ದರಿಂದ ಈ ಒಂದು ಸಂಖ್ಯೆಯ ಅಪವರ್ತನೀಯ ಲೆಕ್ಕಾಚಾರ ಕಾಣಿಸುತ್ತದೆ.

889
00:54:15,090 --> 00:54:17,790
ಅಪ್ ನಮ್ಮ ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಂದಿರುತ್ತದೆ ಇಲ್ಲಿ ಮೇಲಕ್ಕೆ.

890
00:54:17,790 --> 00:54:22,330
N ≤ 1, ನಾವು ಮತ್ತೆ ಅಪವರ್ತನೀಯ ಕರೆಯಲು ಹೋಗುತ್ತಿಲ್ಲ ಆ ಸಂದರ್ಭದಲ್ಲಿ.

891
00:54:22,330 --> 00:54:26,490
ನಾವು ನಿಲ್ಲಿಸಲು ನೀನು; ನಾವು ಕೆಲವು ಮೌಲ್ಯವನ್ನು ಮರಳಲು ನೀನು.

892
00:54:26,490 --> 00:54:30,170
ಈ ನಿಜವಾದ ಇದ್ದರೆ, ಆಗ ನಮ್ಮ ಪುನರಾವರ್ತಿತ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಡೆಯಲು ನೀನು.

893
00:54:30,170 --> 00:54:33,550
ಬಹಳ ಉಪಯುಕ್ತ ಎಂದು ಏಕೆಂದರೆ ನಾವು, ಅಪವರ್ತನೀಯ (N) ಕರೆ ಎಂಬುದಾಗಿ ನೀವು ಇಲ್ಲಿ ಗಮನಿಸಿ.

894
00:54:33,550 --> 00:54:36,810
ನಾವು ಮತ್ತೇನನ್ನೋ ಅಪವರ್ತನೀಯ ಕರೆಯಲು ನೀನು.

895
00:54:36,810 --> 00:54:40,850
>> ಮತ್ತು ನೀವು, ನಾವು ಅಪವರ್ತನೀಯ (5) ಅಥವಾ ಏನಾದರೂ ಹಾದು ಅಂತಿಮವಾಗಿ ವೇಳೆ, ನೋಡಬಹುದು

896
00:54:40,850 --> 00:54:45,900
ನಾವು ಅಪವರ್ತನೀಯ (4) ಮತ್ತು ಹೀಗೆ ಕರೆಯಲು ನೀನು, ಮತ್ತು ಅಂತಿಮವಾಗಿ ಈ ಬೇಸ್ ಸಂದರ್ಭದಲ್ಲಿ ಹೊಡೆಯಲು ನೀನು.

897
00:54:45,900 --> 00:54:51,730
ಆದ್ದರಿಂದ ಈ ಚೆನ್ನಾಗಿ ಕಾಣುತ್ತದೆ. ನಾವು ವಾಸ್ತವವಾಗಿ ಈ ರನ್, ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

898
00:54:51,730 --> 00:54:57,840
ಈ ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಈಗ ಮುಖ್ಯ ವಾದವನ್ನು (4) ಈ ಕಾರ್ಯ ಕರೆ ಹೋಗಿ ಎಂದು ಹೇಳುತ್ತಾರೆ.

899
00:54:57,840 --> 00:55:02,200
ಹಾಗೆ ಒಮ್ಮೆ ಅಪವರ್ತನೀಯ ನೋಡುತ್ತಾನೆ ಮತ್ತು = 4, ಅಪವರ್ತನೀಯ ಸ್ವತಃ ಕರೆಯುತ್ತೇವೆ.

900
00:55:02,200 --> 00:55:05,010
ಈಗ, ಇದ್ದಕ್ಕಿದ್ದಂತೆ, ನಾವು (3) ಅಪವರ್ತನೀಯ ಹೊಂದಿರುತ್ತವೆ.

901
00:55:05,010 --> 00:55:10,780
ಆದ್ದರಿಂದ ಈ ಕಾರ್ಯಗಳು ಅಂತಿಮವಾಗಿ ನಾವು ನಮ್ಮ ಮೂಲ ಸಂದರ್ಭದಲ್ಲಿ ಹಿಟ್ ರವರೆಗೆ ಬೆಳೆಯುತ್ತಿರುವ ಇರಿಸಿಕೊಳ್ಳಲು ಹೋಗುವ.

902
00:55:10,780 --> 00:55:17,830
ಈ ಹಂತದಲ್ಲಿ, ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ರಿಟರ್ನ್ (NX ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು), ಆಗಿದೆ

903
00:55:17,830 --> 00:55:21,290
ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಈ NX ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ.

904
00:55:21,290 --> 00:55:23,290
ಅಂತಿಮವಾಗಿ ನಾವು ಕೆಲವು ಸಂಖ್ಯೆಯ ಹೊಡೆಯಲು ಬೇಕಾಗುತ್ತದೆ.

905
00:55:23,290 --> 00:55:26,560
ಇಲ್ಲಿ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಾವು ರಿಟರ್ನ್ 1 ಹೇಳುತ್ತಾರೆ.

906
00:55:26,560 --> 00:55:30,650
ಒಮ್ಮೆ ನಾವು ಸಂಖ್ಯೆ ಮರಳಿ ಎಂದು ಅರ್ಥ, ನಾವು ಸ್ಟಾಕ್ ಆಫ್ ಈ ಪಾಪ್ ಮಾಡಬಹುದು.

907
00:55:30,650 --> 00:55:36,570
ಆದ್ದರಿಂದ ಈ ಅಪವರ್ತನೀಯ (1) ಮಾಡಲಾಗುತ್ತದೆ.

908
00:55:36,570 --> 00:55:41,190
ಆಗ 1 ಮರಳುತ್ತದೆ, ಈ ಅಪವರ್ತನೀಯ (1) ಹಿಂತಿರುಗುತ್ತದೆ 1 ಮರಳಿ.

909
00:55:41,190 --> 00:55:46,910
ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು, ನೆನಪಿಡಿ, ಈ ಮರಳುವ ಮೌಲ್ಯವನ್ನು NX ಆಗಿತ್ತು.

910
00:55:46,910 --> 00:55:50,720
ಆದ್ದರಿಂದ ಇದ್ದಕ್ಕಿದ್ದಂತೆ, ಈ ವ್ಯಕ್ತಿ ನಾನು 2 ಮರಳಲು ಬಯಸುವ ತಿಳಿದಿದೆ.

911
00:55:50,720 --> 00:55:55,910
>> ಆದ್ದರಿಂದ, ಮರೆಯದಿರಿ ಈ ಮೌಲ್ಯವನ್ನು ಇಲ್ಲಿ ಮರಳುವ ಮೌಲ್ಯವನ್ನು ಕೇವಲ NX ಅಪ್ ಹಿಂತಿರುಗಿ.

912
00:55:55,910 --> 00:56:01,160
ಈಗ ನಾವು 3 x 2 ಹೇಳಬಹುದು, ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಇಲ್ಲಿ ನಾವು ಹೇಳಬಹುದು

913
00:56:01,160 --> 00:56:04,010
ಈ ಕೇವಲ 4 x 3 x 2 ಎಂದು ಹೋಗುತ್ತದೆ.

914
00:56:04,010 --> 00:56:09,570
ಮತ್ತು ಈ ಮರಳುತ್ತದೆ ಒಮ್ಮೆ ನಾವು ಮುಖ್ಯ ಒಂದು ಪೂರ್ಣಾಂಕ ಒಳಗೆ ಕೆಳಗೆ ಪಡೆಯುವುದು.

915
00:56:09,570 --> 00:56:15,460
ರಿಕರ್ಶನ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

916
00:56:15,460 --> 00:56:17,090
ಎಲ್ಲಾ ಸರಿ. ಆದ್ದರಿಂದ ಪ್ರಶ್ನೆಗಳಿಗೆ ಹೆಚ್ಚಿನ ಸಮಯ, ಕೊನೆಯಲ್ಲಿ ಇಲ್ಲ

917
00:56:17,090 --> 00:56:23,360
ಆದರೆ ಈಗ ಜೋಸೆಫ್ ಉಳಿದ ವಿಷಯಗಳು ಕ್ರಮಿಸುತ್ತದೆ.

918
00:56:23,360 --> 00:56:25,590
>> [ಜೋಸೆಫ್ ಓಂಗ್] ಸರಿ. ಈಗ ನಾವು recursions ಬಗ್ಗೆ ಮಾತನಾಡಿದರು ಮಾಡಿರುವುದರಿಂದ,

919
00:56:25,590 --> 00:56:27,840
ನ ತೆರನಾದ ವಿಲೀನಗೊಳ್ಳಲು ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಮಾತನಾಡೋಣ.

920
00:56:27,840 --> 00:56:31,740
ವಿಲೀನಗೊಳ್ಳಲು ರೀತಿಯ ಮೂಲತಃ ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸುವ ಮತ್ತೊಂದು ದಾರಿ.

921
00:56:31,740 --> 00:56:36,430
ಮತ್ತು ವಿಲೀನ ರೀತಿಯ ಜೊತೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ನೀವು ಒಂದು ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದ್ದು, ಮತ್ತು ನಾವು ಆಗಿದೆ

922
00:56:36,430 --> 00:56:39,120
ನಾವು ನ 2 ಹಂತವಾಗಿ ಈ ಬೇರ್ಪಟ್ಟು ಅವಕಾಶ ಹೇಳುತ್ತಾರೆ.

923
00:56:39,120 --> 00:56:42,750
ನಾವು ಮೊದಲು ಎಡ ಅರ್ಧದಲ್ಲಿ ಮತ್ತೆ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ರನ್ ಮಾಡುತ್ತೇವೆ

924
00:56:42,750 --> 00:56:45,040
ನಂತರ ನಾವು ಬಲ ಅರ್ಧದಲ್ಲಿ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ರನ್ ಮಾಡುತ್ತೇವೆ

925
00:56:45,040 --> 00:56:50,240
ಮತ್ತು ಈಗ ನಮಗೆ ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ ಎಂದು 2 ಅರ್ಥ ನೀಡುತ್ತದೆ ಮತ್ತು ಈಗ ನಾವು ಒಟ್ಟಾಗಿ ಆ ಅರ್ಥ ಸಂಯೋಜಿಸಲು ನೀನು.

926
00:56:50,240 --> 00:56:55,010
ಇದು ಉದಾಹರಣೆಗೆ ಯಾವುದೇ ನೋಡಲು ಸ್ವಲ್ಪ ಕಷ್ಟ, ಆದ್ದರಿಂದ ನಾವು ಚಲನೆಗಳ ಮೂಲಕ ಹೋಗಿ ಏನಾಗುತ್ತದೆ ನೋಡುತ್ತಾರೆ.

927
00:56:55,010 --> 00:56:59,590
ಆದ್ದರಿಂದ ಈ ಪಟ್ಟಿಯನ್ನು, ನಾವು 2 ಅರ್ಥ ವಿಭಾಗಿಸಿರಿ ಪ್ರಾರಂಭಿಸಿ.

928
00:56:59,590 --> 00:57:02,300
ನಾವು ಮೊದಲ ಎಡ ಅರ್ಧದಲ್ಲಿ ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು ರನ್.

929
00:57:02,300 --> 00:57:06,660
ಆದ್ದರಿಂದ ಎಡ ಅರ್ಧ, ಮತ್ತು ಈಗ ನಾವು ಮತ್ತೆ ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಮೂಲಕ ರನ್

930
00:57:06,660 --> 00:57:09,800
ಇದು ನಾವು, ಮತ್ತೆ, ನೋಡಲು ನಂತರ ವಿಲೀನ ರೀತಿಯ ರವಾನೆಯಾದವು, ಮತ್ತು ಮುಟ್ಟುತ್ತದೆ

931
00:57:09,800 --> 00:57:13,270
ಈ ಪಟ್ಟಿಯ ಎಡಭಾಗದಲ್ಲಿ ಮತ್ತು ನಾವು ಮೇಲೆ ವಿಂಗಡಿಸಿ ವಿಲೀನಗೊಳ್ಳಲು ರನ್.

932
00:57:13,270 --> 00:57:15,880
ಈಗ, ನಾವು, 2 ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಕೆಳಗೆ ಪಡೆಯಿರಿ

933
00:57:15,880 --> 00:57:19,010
ಮತ್ತು ಈಗ ಎಡ ಅರ್ಧ ಮಾತ್ರ 1 ಅಂಶ ಉದ್ದವಾಗಿದೆ ಮತ್ತು ನಾವು

934
00:57:19,010 --> 00:57:23,380
ಅರ್ಧದಷ್ಟನ್ನು ಮಾತ್ರ 1 ಅಂಶ ಎಂದು ಪಟ್ಟಿಯನ್ನು ಬೇರ್ಪಟ್ಟು, ಆದ್ದರಿಂದ ನಾವು ಒಮ್ಮೆ ನಾವು 50 ಹೊಂದಿವೆ, ಹೇಳುತ್ತಾರೆ,

935
00:57:23,380 --> 00:57:26,400
ಇದು ಕೇವಲ 1 ಅಂಶ, ಇದು ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ನ.

936
00:57:26,400 --> 00:57:29,860
>> ನಾವು ಪೂರೈಸಿದ ನಂತರ, ನಾವು ನಾವು ನೋಡಬಹುದು

937
00:57:29,860 --> 00:57:32,230
ಈ ಪಟ್ಟಿಯ ಬಲ ಅರ್ಧ ಕಡೆಗೆ,

938
00:57:32,230 --> 00:57:36,480
ಮತ್ತು 3, ಆದ್ದರಿಂದ ಈಗ ಈ ಪಟ್ಟಿಯ ಎರಡೂ ಅರ್ಥ ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ ಎಂದು ವಿಂಗಡಿಸಿ, ಮತ್ತು

939
00:57:36,480 --> 00:57:39,080
ನಾವು ಮತ್ತೆ ಒಟ್ಟಿಗೆ ಈ ಸಂಖ್ಯೆಗಳನ್ನು ಸೇರಬಹುದು.

940
00:57:39,080 --> 00:57:45,320
ನಾವು 50 ಮತ್ತು 3 ನೋಡಲು; 3 50 ಚಿಕ್ಕದಾಗಿದೆ, ಆದ್ದರಿಂದ ಮೊದಲ ಹೋಗುತ್ತಾನೆ ಮತ್ತು ನಂತರ 50 ಸೈನ್ ಬರುತ್ತದೆ

941
00:57:45,320 --> 00:57:49,340
ಈಗ ಆ ನಿಲ್ಲಿಸುವುದಾಗಿ; ನಾವು ಬಲ ಅರ್ಧ ಎಂದು ಪಟ್ಟಿ ಮತ್ತು ರೀತಿಯ ಹಿಂದಿರುಗಿ ಹೋಗಿ.

942
00:57:49,340 --> 00:57:52,440
42 ಇದು ಆದ ಸಂಖ್ಯೆ, ಆದ್ದರಿಂದ ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾದ ನ.

943
00:57:52,440 --> 00:57:57,850
ಈಗ ನಾವು, ಮೊದಲ ಪುಟ್ ಗಳಿಸುವ ಆದ್ದರಿಂದ, 2 ಮತ್ತು 3 42 ಚಿಕ್ಕದಾಗಿದೆ ಈ ಹೋಲಿಕೆ

944
00:57:57,850 --> 00:58:02,340
ಈಗ 42 ರಲ್ಲಿ ಪುಟ್ ಮಾಡಲ್ಪಡುತ್ತವೆ, ಮತ್ತು 50 ಸೈನ್ ಪುಟ್ ಮುಟ್ಟುತ್ತದೆ

945
00:58:02,340 --> 00:58:07,220
ಈಗ ಪ್ರತಿಗಳ ಎಂದು, ನಾವು, ಮೇಲಕ್ಕೆ ಹಿಂದೆ 1337 ಮತ್ತು 15 ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ.

946
00:58:07,220 --> 00:58:14,560
ಹಾಗೆಯೇ, ನಾವು ಈಗ ಈ ಪಟ್ಟಿಯ ಎಡ ಅರ್ಧ ನೋಡಲು; 1337 ಸ್ವತಃ ಆದ್ದರಿಂದ ಇದು 15 ಮೂಲಕ ಪ್ರತ್ಯೇಕಿಸಬಹುದು ಮತ್ತು ಅದೇ ಸ್.

947
00:58:14,560 --> 00:58:19,020
ಈಗ ನಾವು ಮೂಲ ಪಟ್ಟಿ, 15 <1337, ವಿಂಗಡಿಸಲು ಈ 2 ಸಂಖ್ಯೆಗಳು ಒಗ್ಗೂಡಿ

948
00:58:19,020 --> 00:58:23,060
ಆದ್ದರಿಂದ ಮೊದಲ ಹೋಗುತ್ತದೆ, ನಂತರ 1337 ಸೈನ್ ಹೋಗುತ್ತದೆ

949
00:58:23,060 --> 00:58:26,640
ಮತ್ತು ಈಗ ನಾವು ಟಾಪ್ ಅಪ್ ಮೂಲ ಪಟ್ಟಿಯನ್ನು ಎರಡೂ ಅರ್ಥ ವಿಂಗಡಿಸುತ್ತದೆ.

950
00:58:26,640 --> 00:58:30,440
ಮತ್ತು ನಾವು ಎಲ್ಲಾ ಈ ಒಟ್ಟುಗೂಡುತ್ತವೆ.

951
00:58:30,440 --> 00:58:36,890
ಈ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ 2 ಸಂಖ್ಯೆಗಳು 3 <15 ನೋಡಲು, ಆದ್ದರಿಂದ ಮೊದಲ ರೀತಿಯ ಸರಣಿ ಹೋಗುತ್ತದೆ.

952
00:58:36,890 --> 00:58:44,460
15 <42, ಆದ್ದರಿಂದ, ಈಗ ಸೈನ್ ಹೋಗುತ್ತದೆ 42 <1337, ಆ ಸೈನ್ ಹೋಗುತ್ತದೆ

953
00:58:44,460 --> 00:58:51,010
50 <1337, ಆದ್ದರಿಂದ ಸೈನ್ ಹೋಗುತ್ತದೆ ಮತ್ತು ನಾವು ಈ ಪಟ್ಟಿಯ 2 ಸಂಖ್ಯೆಗಳು ಹಾರಿದ ಗಮನಿಸಿ.

954
00:58:51,010 --> 00:58:53,640
ಆದ್ದರಿಂದ ನಾವು 2 ಪಟ್ಟಿಗಳನ್ನು ನಡುವಿನ ಪರ್ಯಾಯ ಇಲ್ಲ.

955
00:58:53,640 --> 00:58:56,050
ನಾವು ಆರಂಭದಲ್ಲಿ ಹುಡುಕುತ್ತಿರುವ, ಮತ್ತು ನಾವು ಅಂಶ ತೆಗೆದುಕೊಳ್ಳುವ ನೀವು

956
00:58:56,050 --> 00:59:00,270
ಸಣ್ಣ ಮತ್ತು ನಂತರ ನಮ್ಮ ವ್ಯೂಹವನ್ನು ಅದನ್ನು ಪುಟ್ಟಿಂಗ್ ದ.

957
00:59:00,270 --> 00:59:04,080
ಈಗ ನಾವು ಎಲ್ಲಾ ಅರ್ಥ ವಿಲೀನಗೊಂಡಿತು ನೀವು ಮತ್ತು ನಾವು ಮುಗಿಸಿದ್ದೀರಿ.

958
00:59:04,080 --> 00:59:07,780
>> ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ರೀತಿಯ ವಿಲೀನಗೊಳ್ಳಲು? ಹೌದು?

959
00:59:07,780 --> 00:59:14,190
[ವಿದ್ಯಾರ್ಥಿ] ಇದು ವಿಭಿನ್ನ ಗುಂಪುಗಳಾಗಿ ವಿಭಾಗಿಸಿ ಸರಿ, ಏಕೆ ಅವರು ಕೇವಲ ಒಮ್ಮೆ ಬೇರ್ಪಟ್ಟು ಇಲ್ಲ

960
00:59:14,190 --> 00:59:19,970
ಮತ್ತು ನೀವು ಒಂದು ಗುಂಪಿನಲ್ಲಿ 3 ಮತ್ತು 2 ಹೊಂದಿವೆ? [ಪ್ರಶ್ನೆಯನ್ನು ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ ಉಳಿದ]

961
00:59:19,970 --> 00:59:24,940
ಕಾರಣ - ಹೀಗೆ ಪ್ರಶ್ನೆ, ನಾವು ಅವುಗಳನ್ನು ನಂತರ ಏಕೆ ನಾವು ಮೊದಲ ಹಂತದಲ್ಲಿ ಅವರನ್ನು ವಿಲೀನಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ?

962
00:59:24,940 --> 00:59:29,530
ನಾವು ಈ ಮಾಡಬಹುದು ಕಾರಣ, ಎರಡೂ ಎಡ ಅತ್ಯಂತ ಅಂಶಗಳನ್ನು ಆರಂಭವಾಗುವುದು

963
00:59:29,530 --> 00:59:33,040
ತದನಂತರ, ಸಣ್ಣ ಒಂದು ತೆಗೆದುಕೊಂಡು ಅದನ್ನು ಇರಿಸಲಾಯಿತು ನಾವು ಈ ತಿಳಿದಿದೆ ಎಂದು

964
00:59:33,040 --> 00:59:35,290
ಮಾಲಿಕ ಪಟ್ಟಿಗಳನ್ನು ವಿಂಗಡಿಸಲಾದ ಆದೇಶಗಳನ್ನು ಇವೆ.

965
00:59:35,290 --> 00:59:37,290
ನಾನು ಎರಡೂ ಅರ್ಥ ಎಡ ಅತ್ಯಂತ ಅಂಶಗಳನ್ನು ಬಯಸುತ್ತೇನೆ ಹಾಗಾಗಿ,

966
00:59:37,290 --> 00:59:40,490
ನಾನು ಆ ಪಟ್ಟಿಗಳನ್ನು ಚಿಕ್ಕ ಅಂಶಗಳು ಎಂದು ನೀನು ತಿಳಿದಿದೆ.

967
00:59:40,490 --> 00:59:43,930
ಆದ್ದರಿಂದ ನಾನು ಈ ದೊಡ್ಡ ಪಟ್ಟಿಯ ಚಿಕ್ಕ ಅಂಶ ತಾಣಗಳು ಅವುಗಳನ್ನು ಹಾಕಬಹುದು.

968
00:59:43,930 --> 00:59:47,810
ಮತ್ತೊಂದೆಡೆ, ನಾನು ಮೇಲೆ ಎರಡನೆಯ ಮಟ್ಟದಲ್ಲಿ ಆ 2 ಪಟ್ಟಿಗಳನ್ನು ನೋಡಿದರೆ,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 ಮತ್ತು 15, ಆ ವಿಂಗಡಿಸಲಾದ ಇಲ್ಲ.

970
00:59:51,640 --> 00:59:55,770
ನಾನು 50 ಮತ್ತು 1337 ನೋಡಲು ಆದ್ದರಿಂದ, ನಾನು ನನ್ನ ಮೊದಲ ಪಟ್ಟಿ 50 ಪುಟ್ ಪಡೆಯಲಿದ್ದೇನೆ.

971
00:59:55,770 --> 01:00:00,130
ಆದರೆ ನಿಜವಾಗಿಯೂ 3 ಆ ಎಲ್ಲಾ ಔಟ್ ಚಿಕ್ಕ ಅಂಶ ಏಕೆಂದರೆ, ಅರ್ಥದಲ್ಲಿ ಮಾಡುವುದಿಲ್ಲ.

972
01:00:00,130 --> 01:00:04,390
ಆದ್ದರಿಂದ ನಾವು ಈ ತುಲನೆ ಹಂತದ ಮಾಡಬಹುದು ಏಕೈಕ ಕಾರಣವೆಂದರೆ ನಮ್ಮ ಪಟ್ಟಿಗಳನ್ನು ಈಗಾಗಲೇ ವಿಂಗಡಿಸಲಾಗುತ್ತದೆ ಏಕೆಂದರೆ.

973
01:00:04,390 --> 01:00:07,010
ನಾವು ಕೆಳಗೆ ಎಲ್ಲಾ ವೇ ಡೌನ್ ಪಡೆಯಲು ಏಕೆ ಇದು

974
01:00:07,010 --> 01:00:09,800
ನಾವು ಒಂದು ಸಂಖ್ಯೆಯ ಮಾಡಿದಾಗ, ನೀವು ಒಂದು ಏಕೈಕ ಸಂಖ್ಯೆ ತಿಳಿದಿರುವ ಕಾರಣ

975
01:00:09,800 --> 01:00:14,120
ಮತ್ತು ಸ್ವತಃ ಈಗಾಗಲೇ ಪ್ರತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಹೊಂದಿದೆ.

976
01:00:14,120 --> 01:00:19,360
>> ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಇಲ್ಲ?

977
01:00:19,360 --> 01:00:24,260
ಸಂಕೀರ್ಣತೆ? ಅಲ್ಲದೆ, ನೀವು, ಪ್ರತಿ ಹಂತದಲ್ಲೂ ಕೊನೆಯಲ್ಲಿ ಸಂಖ್ಯೆಗಳು ಇಲ್ಲ ಎಂದು ನೋಡಬಹುದು

978
01:00:24,260 --> 01:00:27,590
ಮತ್ತು ನಾವು, ಅರ್ಧ ಲಾಗ್ N ಕಾಲದಲ್ಲಿ ಪಟ್ಟಿಯನ್ನು ಭಾಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ

979
01:00:27,590 --> 01:00:31,700
ಈ X N ಲಾಗ್ N ಸಂಕೀರ್ಣತೆ ಪಡೆಯಲು ಅಲ್ಲಿ ಇದು.

980
01:00:31,700 --> 01:00:34,940
ಮತ್ತು ನೀವು ವಿಲೀನ ರೀತಿಯ ಅತ್ಯುತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ N ಲಾಗ್ N ಹೊಂದಿದೆ ನೋಡುತ್ತಾರೆ, ಮತ್ತು ಇದು ಆದ್ದರಿಂದ ಸಂಭವಿಸುತ್ತದೆ

981
01:00:34,940 --> 01:00:39,340
ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಅಥವಾ ಅಲ್ಲಿರುವ Ω, ಸಹ N N ಲಾಗ್ ಎಂದು.

982
01:00:39,340 --> 01:00:42,480
ನೆನಪಿನಲ್ಲಿಡಿ ಏನಾದರೂ.

983
01:00:42,480 --> 01:00:45,750
ಮೇಲೆ ಚಲಿಸುವ, ಅವರ ಕೆಲವು ಸೂಪರ್ ಮೂಲ ಕಡತ I / O ಗೆ ಹೋಗಿ ಅವಕಾಶ

984
01:00:45,750 --> 01:00:48,830
ನೀವು ಸ್ಕ್ರ್ಯಾಂಬಲ್ ನೋಡಿವೆ ವೇಳೆ, ನಾವು ವ್ಯವಸ್ಥೆಯ ಕೆಲವು ರೀತಿಯ ಹೊಂದಿತ್ತು ಗಮನಕ್ಕೆ ಮಾಡುತ್ತೇವೆ

985
01:00:48,830 --> 01:00:51,270
ನೀವು ಕೋಡ್ ಓದಲು ನೀವು ಲಾಗ್ ಕಡತಕ್ಕೆ ಬರೆಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

986
01:00:51,270 --> 01:00:53,730
ನ ನೀವು ಹಾಗೆ ಹೇಗೆ ನೋಡೋಣ.

987
01:00:53,730 --> 01:00:57,450
ಹಾಗೆಯೇ, ನಾವು fprintf ಹೊಂದಿದ್ದರೆ, ನೀವು, ಎಂದು ಕೇವಲ printf ನಗರದ ಇದು

988
01:00:57,450 --> 01:01:01,720
ಆದರೆ ಆರಂಭದಲ್ಲಿ F ಆದ್ದರಿಂದ ಬದಲಿಗೆ ಕಡತ ಮುದ್ರಿಸುವ, ಮತ್ತು.

989
01:01:01,720 --> 01:01:07,570
ಅಪ್ ಇಲ್ಲಿ ಕೋಡ್ ಈ ರೀತಿಯ, ನೀವು ಸ್ಕ್ರ್ಯಾಂಬಲ್ ಕಂಡ ಇರಬಹುದು ಎಂದು ಅದು ಏನು ಮಾಡುತ್ತದೆ, ಆಗಿದೆ,

990
01:01:07,570 --> 01:01:12,310
ಇದು ಸಂಖ್ಯೆಗಳನ್ನು ಯಾವ ಸಾಲಿನ ಮೂಲಕ ಸಾಲು ನಿಮ್ಮ 2 ಆಯಾಮದ ರಚನೆಯ ಮುದ್ರಣ ಮೂಲಕ ಹೋಗುತ್ತದೆ.

991
01:01:12,310 --> 01:01:17,850
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಿಮ್ಮ printf ಟರ್ಮಿನಲ್ಗೆ ಔಟ್ ತೋರಿಸುತ್ತದೆ ಅಥವಾ ನಾವು ವಿಭಾಗ ಪ್ರಮಾಣಿತ ಔಟ್ಪುಟ್ ಕರೆಯುವ.

992
01:01:17,850 --> 01:01:22,170
>> ಈಗ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಎಲ್ಲಾ fprintf ಜೊತೆ printf ಸ್ಥಾನವನ್ನು ಹೊಂದಿದೆ

993
01:01:22,170 --> 01:01:26,770
ನೀವು ಮುದ್ರಿಸಲು ಯಾವ ಫೈಲ್ ಅದನ್ನು ತಿಳಿಸಿ, ಮತ್ತು ಈ ವಿಚಾರದಲ್ಲಿ, ಅದು ಕೇವಲ ಫೈಲ್ ಇದನ್ನು ತೋರಿಸುತ್ತದೆ

994
01:01:26,770 --> 01:01:32,230
ಬದಲಿಗೆ ನಿಮ್ಮ ಟರ್ಮಿನಲ್ ಅದನ್ನು ಔಟ್ ಮುದ್ರಣ.

995
01:01:32,230 --> 01:01:36,500
ಅಲ್ಲದೆ, ಆ ಪ್ರಶ್ನೆಯನ್ನು ಬೇಡಿಕೊಂಡಳು: ಎಲ್ಲಿ ನಾವು, ಫೈಲ್ ಅನ್ನು ಈ ರೀತಿಯ ಸಿಗುತ್ತವೆ?

996
01:01:36,500 --> 01:01:39,840
ಈ fprintf fuction ಪ್ರವೇಶಿಸಲು ಜಾರಿಗೆ ಆದರೆ ನಾವು ಬಂದ ಅಲ್ಲಿ ಕಲ್ಪನೆ ಇರಲಿಲ್ಲ.

997
01:01:39,840 --> 01:01:43,980
ಅಲ್ಲದೆ, ಆರಂಭದಲ್ಲಿ ಕೋಡ್ ನಲ್ಲಿ, ನಾವು ಹೊಂದಿದ್ದು, ಇಲ್ಲಿ ಸುಮಾರು ಕೋಡ್ ಈ ಚಂಕ್ ಆಗಿತ್ತು

998
01:01:43,980 --> 01:01:48,340
ಮೂಲತಃ ತೆರೆದ ಕಡತ log.txt ಅಪೇಕ್ಷಿಸುವ ಹೇಳುತ್ತದೆ.

999
01:01:48,340 --> 01:01:53,220
ಆ ನಂತರ ನಾವು ನಾವು ಫೈಲ್ ವಾಸ್ತವವಾಗಿ ಯಶಸ್ವಿಯಾಗಿ ಆರಂಭವಾಯಿತು ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು.

1000
01:01:53,220 --> 01:01:57,070
ಆದ್ದರಿಂದ ಅನೇಕ ಕಾರಣಗಳಿಗೆ ಕೆಲಸ ಮಾಡದೆ ಇರಬಹುದು; ನೀವು ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಗಣಕದಲ್ಲಿ ಸಾಕಷ್ಟು ಸ್ಥಳವನ್ನು ಹೊಂದಿಲ್ಲ.

1001
01:01:57,070 --> 01:01:59,790
ನೀವು ಫೈಲ್ ಯಾವುದೇ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಮೊದಲು ಆದ್ದರಿಂದ ಯಾವಾಗಲೂ ಪ್ರಮುಖ

1002
01:01:59,790 --> 01:02:03,300
ಆ ಫೈಲ್ ಯಶಸ್ವಿಯಾಗಿ ತೆರೆಯಲಾಯಿತು ಎಂದು ಪರಿಶೀಲಿಸಿ ಎಂದು.

1003
01:02:03,300 --> 01:02:09,330
ಹಾಗಾಗಿ ಒಂದು, ಆ fopen ಒಂದು ವಾದದ ಪ್ರಕಾರ, ಹಾಗೆಯೇ, ನಾವು ಅನೇಕ ವಿಧಗಳಲ್ಲಿ ಒಂದು ಕಡತವನ್ನು ತೆರೆಯುತ್ತದೆ.

1004
01:02:09,330 --> 01:02:13,510
ನಾವು ಹೊಂದಿದೆ ಏನು ಮಾಡಬಹುದು, ನಾವು, ಇದು ಹೊರಹೋಗುವ ವೇಳೆ ಈಗಾಗಲೇ ಫೈಲ್ ಅತಿಕ್ರಮಿಸಲಾಗುವುದಿಲ್ಲ ಅಂದರೆ, ಇದು W ಹಸ್ತಾಂತರಿಸುತ್ತಾನೆ

1005
01:02:13,510 --> 01:02:18,070
ನಾವು, ಅವರು ಬದಲಿಗೆ ಇದು ಅತಿ ಮುಖ್ಯ ಫೈಲ್ ಕೊನೆಗೆ ಸೇರಿಸಲು ಇದು, ಒಂದು ಪಾಸ್ ಮಾಡಬಹುದು

1006
01:02:18,070 --> 01:02:22,730
ಅಥವಾ ನಾವು ಅಂದರೆ, R ಸೂಚಿಸಬಹುದು, ಫೈಲ್ ಓದಲು ಮಾತ್ರ ತೆರೆಯಲು ಅವಕಾಶ.

1007
01:02:22,730 --> 01:02:24,890
ಪ್ರೋಗ್ರಾಂ, ಫೈಲ್ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ ಹಾಗಿದ್ದಲ್ಲಿ

1008
01:02:24,890 --> 01:02:30,140
ಅವುಗಳನ್ನು ಕೂಗಿ ಮತ್ತು ಅವುಗಳನ್ನು ಮಾಡಲಿ ಇಲ್ಲ.

1009
01:02:30,140 --> 01:02:33,320
ಅಂತಿಮವಾಗಿ, ಒಮ್ಮೆ ನಾವು, ಅದರ ಮೇಲೆ ಕಾರ್ಯಾಚರಣೆ ಮಾಡುವ ಆಯಿತು, ಕಡತ ಪೂರೈಸಿದ

1010
01:02:33,320 --> 01:02:35,860
ನಾವು ಫೈಲ್ ಮುಚ್ಚಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಅಗತ್ಯವಿದೆ.

1011
01:02:35,860 --> 01:02:38,830
ಮತ್ತು ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಮತ್ತೆ ಅವುಗಳನ್ನು ಹಾದು ಹೋಗುವ

1012
01:02:38,830 --> 01:02:42,120
ನೀವು ತೆರೆಯಿತು, ಮತ್ತು ಅದನ್ನು ಮುಚ್ಚಿ ಈ ಫೈಲ್ ಆ.

1013
01:02:42,120 --> 01:02:44,650
ಆದ್ದರಿಂದ ಈ ನೀವು ಖಾತ್ರಿಪಡಿಸಿಕೊಳ್ಳಿ ಅವುಗಳ ಪ್ರಮುಖ ಸಂಗತಿಯಾಗಿದೆ.

1014
01:02:44,650 --> 01:02:47,180
ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಕಡತವನ್ನು ತೆರೆಯಲು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಿ, ನಂತರ ನೀವು, ಕಡತ ಬರೆಯಬಹುದು

1015
01:02:47,180 --> 01:02:51,270
ಕಡತದಲ್ಲಿ ಕಾರ್ಯಾಚರಣೆಯನ್ನು, ಆದರೆ ನೀವು ಕೊನೆಯಲ್ಲಿ ಕಡತವನ್ನು ಮುಚ್ಚಲು ಹೊಂದಿರುತ್ತವೆ.

1016
01:02:51,270 --> 01:02:53,270
>> ಮೂಲ ಫೈಲ್ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ನಾನು / ಓ? ಹೌದು?

1017
01:02:53,270 --> 01:02:58,050
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

1018
01:02:58,050 --> 01:03:02,480
ಇಲ್ಲಿಯೇ. ಪ್ರಶ್ನೆ, ಈ log.txt ಫೈಲ್ ಅಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಇದೆ?

1019
01:03:02,480 --> 01:03:07,890
ನೀವು ಅದನ್ನು log.txt ಕೊಟ್ಟರೆ ಅಲ್ಲದೆ, ಇದು ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಅದೇ ಕೋಶದಲ್ಲಿನ ಇದು ಸೃಷ್ಟಿಸುತ್ತದೆ.

1020
01:03:07,890 --> 01:03:10,500
ಆದ್ದರಿಂದ you're ವೇಳೆ - >> [ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆ, ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

1021
01:03:10,500 --> 01:03:18,830
ಹೌದು. ಒಂದೇ ಕಡತದಲ್ಲಿ, ಅಥವಾ ಅದೇ ಕೋಶದಲ್ಲಿನ, ನೀವು ಕರೆ.

1022
01:03:18,830 --> 01:03:21,400
ಈಗ ಮೆಮೊರಿ, ಸ್ಟಾಕ್, ಮತ್ತು ರಾಶಿ.

1023
01:03:21,400 --> 01:03:23,400
ಆದ್ದರಿಂದ ಕಂಪ್ಯೂಟರ್ ಇರಿಸಲ್ಪಟ್ಟಿವೆ ಸ್ಮರಣೆ ಹೇಗೆ?

1024
01:03:23,400 --> 01:03:26,270
ಅಲ್ಲದೆ, ನೀವು ಇಲ್ಲಿ ಈ ಬ್ಲಾಕ್ನ ತೆರನಾದ ಮೆಮೊರಿ ಕಲ್ಪಿಸಬಹುದಾದ.

1025
01:03:26,270 --> 01:03:30,260
ಮತ್ತು ನೆನಪಿಗಾಗಿ ನಾವು ಅಲ್ಲಿರುವ ಅಂಟಿಕೊಂಡಿತು ರಾಶಿ, ಹಾಗೂ ಕೆಳಗೆ ಎಂದು ಸ್ಟಾಕ್ ಎಂಬ ಏನನ್ನು ಹೊಂದಿರುತ್ತವೆ.

1026
01:03:30,260 --> 01:03:34,480
ಮತ್ತು ರಾಶಿ ಕೆಳಮುಖವಾಗಿ ಬೆಳೆಯುವ ಮತ್ತು ಸ್ಟಾಕ್ ಮೇಲಕ್ಕೆ ಬೆಳೆಯುತ್ತದೆ.

1027
01:03:34,480 --> 01:03:38,620
ಟಾಮಿ ಪ್ರಸ್ತಾಪಿಸಿದ್ದಾರೆ ಆದ್ದರಿಂದ - ಓಹ್, ಚೆನ್ನಾಗಿ, ಮತ್ತು ನಾವು ನಾನು ಎರಡನೇ ಗೆ ಪಡೆಯುತ್ತೀರಿ ಈ ಇತರ 4 ಭಾಗಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ -

1028
01:03:38,620 --> 01:03:42,890
ಟಾಮಿ ಮೊದಲೇ ಹೇಳಿದಂತೆ, ನೀವು ಅವರ ಕಾರ್ಯಗಳನ್ನು ತಮ್ಮನ್ನು ಕರೆ ಮತ್ತು ಪರಸ್ಪರ ಕರೆ ಹೇಗೆ ಗೊತ್ತು?

1029
01:03:42,890 --> 01:03:44,930
ಅವರು ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ಈ ರೀತಿಯ ನಿರ್ಮಿಸಲು.

1030
01:03:44,930 --> 01:03:47,360
ಜೊತೆಗೆ, ಪ್ರಮುಖ ಕರೆಗಳು foo, foo ಸ್ಟಾಕ್ ಮೇಲೆ ಗೆಟ್ಸ್ ವೇಳೆ.

1031
01:03:47,360 --> 01:03:52,430
ಫೂ ಕರೆಗಳನ್ನು ಬಾರ್, ಬಾರ್ ನ ಸ್ಟಾಕ್ ಮೇಲೆ ಪಡೆಯಲು, ಮತ್ತು ನಂತರ ಸ್ಟಾಕ್ ಮೇಲೆ ಬಂದಿದೆ.

1032
01:03:52,430 --> 01:03:57,040
ಅವರು ಹಿಂದಿರುಗಿ ಎಂದು ಮತ್ತು, ಅವರು ಪ್ರತಿ ಸ್ಟಾಕ್ ಹೊರತೆಗೆಯಲಾಗಿತ್ತು ಪಡೆಯುತ್ತೀರಿ.

1033
01:03:57,040 --> 01:04:00,140
ಈ ಸ್ಥಾನಗಳ ಪ್ರತಿ ಮತ್ತು ಮೆಮೊರಿ ಏನು ಹಿಡಿದುಕೊಳ್ಳಿ ಇಲ್ಲ?

1034
01:04:00,140 --> 01:04:03,110
ಅಲ್ಲದೆ, ಪಠ್ಯ ವಿಭಾಗದಲ್ಲಿ ಇದು ಅಗ್ರ, ಪ್ರೋಗ್ರಾಮ್ ಒಳಗೊಂಡಿದೆ.

1035
01:04:03,110 --> 01:04:06,390
ಯಂತ್ರ ಕೋಡ್ ಆದ್ದರಿಂದ, ಇಲ್ಲ ಎಂದು, ಒಮ್ಮೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್.

1036
01:04:06,390 --> 01:04:08,520
ಮುಂದಿನ ಯಾವುದೇ ಜಾಗತಿಕ ಅಸ್ಥಿರ ಆರಂಭಿಸಲಾಗಿಲ್ಲ.

1037
01:04:08,520 --> 01:04:12,660
>> ಆದ್ದರಿಂದ, ನಿಮ್ಮ ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಜಾಗತಿಕ ಅಸ್ಥಿರ ಹೊಂದಿವೆ, ಮತ್ತು ನೀವು ಒಂದು = 5, ಹೇಳುವ

1038
01:04:12,660 --> 01:04:15,260
ಆ ವಿಭಾಗದಲ್ಲಿ ಪುಟ್, ಮತ್ತು ಬಲ ಎಂದು ಅಡಿಯಲ್ಲಿ ಗಳಿಸುವ,

1039
01:04:15,260 --> 01:04:18,990
ನೀವು ಕೇವಲ ಒಂದು ಇಂಟ್ ಯಾವುದೇ ಆರಂಭಗೊಳ್ಳದ ಜಾಗತಿಕ ಅಕ್ಷಾಂಶ ಹೊಂದಿರುತ್ತವೆ

1040
01:04:18,990 --> 01:04:20,990
ಆದರೆ ನೀವು ಏನು ಸಮಾನವಾಗಿರುತ್ತದೆ ಹೇಳುತ್ತಾರೆ ಇಲ್ಲ.

1041
01:04:20,990 --> 01:04:23,870
ಈ ಜಾಗತಿಕ ಚರಗಳಾಗಿವೆ, ಆದ್ದರಿಂದ ಅವರು ಮುಖ್ಯ ಹೊರಗೆ ನೀವು ಅರ್ಥ.

1042
01:04:23,870 --> 01:04:28,560
ಆದ್ದರಿಂದ ಈ ಡಿಕ್ಲೇರ್ಡ್ ಆದರೆ ಆರಂಭಿಸಲಾಗಿಲ್ಲ ಯಾವುದೇ ಜಾಗತಿಕ ಅಸ್ಥಿರ ಅರ್ಥ.

1043
01:04:28,560 --> 01:04:32,310
ಆದ್ದರಿಂದ ಹೇರಳ ಎಂಬುದರ? ಮೆಮೊರಿ ನಾವು ಸ್ವಲ್ಪ ರಲ್ಲಿ ಪಡೆಯುತ್ತೀರಿ ಇದು malloc ಬಳಸಿ ಹಂಚಿಕೆ.

1044
01:04:32,310 --> 01:04:35,990
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸ್ಟಾಕ್ ನಿಮಗೆ ಯಾವುದೇ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳು ಹೊಂದಿವೆ

1045
01:04:35,990 --> 01:04:39,950
ಮತ್ತು ಯಾವುದೇ ಕಾರ್ಯಗಳನ್ನು ನೀವು ಅವರ ನಿಯತಾಂಕಗಳನ್ನು ಯಾವುದೇ ಕರೆ ಇರಬಹುದು.

1046
01:04:39,950 --> 01:04:43,720
ಕೊನೆಯಲ್ಲಿ, ನೀವು ನಿಜವಾಗಿಯೂ, ಪರಿಸರ ವೇರಿಯಬಲ್ಗಳ ಏನು ತಿಳಿಯಲು ಇಲ್ಲ

1047
01:04:43,720 --> 01:04:46,700
ಆದರೆ ನೀವು ಪ್ರೊಗ್ರಾಮನ್ನು ಬಂದಾಗಲೆಲ್ಲಾ, ಸಂಬಂಧ ಏನಾದರೂ ಹಾಗೆ ಇಲ್ಲ

1048
01:04:46,700 --> 01:04:49,550
ಈ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಿರ್ವಹಿಸಿದ ವ್ಯಕ್ತಿಯ ಬಳಕೆದಾರಹೆಸರು ಆಗಿದೆ.

1049
01:04:49,550 --> 01:04:51,550
ಮತ್ತು ಕೆಳಭಾಗದಲ್ಲಿ ರೀತಿಯ ಎಂದು ವಿಶೇಷವೇನು.

1050
01:04:51,550 --> 01:04:54,540
ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಮೌಲ್ಯಗಳು ಇದು ಮೆಮೊರಿ ವಿಳಾಸಗಳನ್ನು, ವಿಷಯದಲ್ಲಿ,

1051
01:04:54,540 --> 01:04:58,170
0 ಅತ್ಯುತ್ತಮ ಆರಂಭದಲ್ಲಿ ಮೌಲ್ಯಗಳು, ಮತ್ತು ಅವರು ಕೆಳಗೆ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಕೆಳಗೆ ಹೋಗಿ.

1052
01:04:58,170 --> 01:05:00,440
ಈ ಪ್ರಕರಣದಲ್ಲಿ, ನೀವು 32-ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಇಂತಹ,

1053
01:05:00,440 --> 01:05:05,390
ಕೆಳಭಾಗದಲ್ಲಿ ವಿಳಾಸಕ್ಕೆ ಎಂದು 32 ಬಿಟ್ಗಳು ಏಕೆಂದರೆ, AF ನಂತರ, 0x ಏರಲಿದೆ

1054
01:05:05,390 --> 01:05:10,890
ಇದು 8 ಬೈಟ್ಸ್, ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ 8 ಬೈಟ್ಗಳು 8 ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಅಂಕೆಗಳು ಅನುರೂಪವಾಗಿದೆ.

1055
01:05:10,890 --> 01:05:20,110
ಆದ್ದರಿಂದ ಕೆಳಗೆ ಇಲ್ಲಿ ನೀವು, ಇಷ್ಟ, 0xffffff ಹೊಂದಿವೆ ಎಂದು ನೀನು, ಮತ್ತು ಅಲ್ಲಿ ನೀವು 0 ಹೊಂದಿವೆ ಎಂದು ನೀನು.

1056
01:05:20,110 --> 01:05:23,660
ಆದ್ದರಿಂದ ಯಾವ ಪಾಯಿಂಟರ್ಸ್ ಇವೆ? ನೀವು ಕೆಲವು ಮೊದಲು ವಿಭಾಗದಲ್ಲಿ ಈ ಒಳಗೊಂಡಿದೆ ಇರಬಹುದು.

1057
01:05:23,660 --> 01:05:26,660
ಆದರೆ ನಾವು ಉಪನ್ಯಾಸ ಅದನ್ನು ಮೇಲೆ ಎಲ್ಲಿಯವರೆಗೆ, ಒಂದು ಪಾಯಿಂಟರ್ ಕೇವಲ ಅಕ್ಷಾಂಶ ರೀತಿಯ ಆದ್ದರಿಂದ

1058
01:05:26,660 --> 01:05:34,030
ಬದಲಿಗೆ 50 ನಂತಹ ಮೌಲ್ಯದ ವಿಧದ, ಇದು ಮೆಮೊರಿ ಕೆಲವು ಸ್ಥಳ ವಿಳಾಸವನ್ನು ಶೇಖರಿಸುತ್ತದೆ ಇದು ಅಂಗಡಿಗಳು.

1059
01:05:34,030 --> 01:05:36,020
ಆ ಮೆಮೊರಿ ಲೈಕ್ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ].

1060
01:05:36,020 --> 01:05:41,120
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಸಿಗುತ್ತಾರೆ ಏನು, ನಾವು, ಒಂದು ಪೂರ್ಣಾಂಕ ಅಥವಾ ಒಂದು ಇಂಟ್ * ಒಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ

1061
01:05:41,120 --> 01:05:46,210
ಮತ್ತು 0xDEADBEEF ಈ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ವಿಳಾಸಕ್ಕೆ ಒಳಗೊಂಡಿದೆ.

1062
01:05:46,210 --> 01:05:50,880
>> ಹಾಗಾಗಿ ನಾವು ಮೆಮೊರಿ ಕೆಲವು ಸ್ಥಳ ಈ ಪಾಯಿಂಟರ್ ಅಂಕಗಳನ್ನು, ಈಗ ಆಗಿದೆ,

1063
01:05:50,880 --> 01:05:56,020
ಮತ್ತು ಕೇವಲ ಅವರ, ಮೌಲ್ಯ 50 ಈ ಮೆಮೊರಿ ಸ್ಥಳ ಆಗಿದೆ.

1064
01:05:56,020 --> 01:06:01,810
ಕೆಲವು 32-ಬಿಟ್ ಗಣಕಗಳಲ್ಲಿ, ಎಲ್ಲಾ 32-ಬಿಟ್ ಗಣಕಗಳಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್ 32 ಬಿಟ್ಗಳು ಅಥವಾ 4 ಬೈಟ್ಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

1065
01:06:01,810 --> 01:06:06,020
ಆದರೆ, ಉದಾಹರಣೆಗೆ, ಒಂದು 64 ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್ 64 ಬಿಟ್ಗಳು ಇವೆ.

1066
01:06:06,020 --> 01:06:08,040
ಆದ್ದರಿಂದ ನೀವು ನೆನಪಿಡಬೇಕು ಬಯಸುವಿರಿ ವಿಷಯ.

1067
01:06:08,040 --> 01:06:12,310
ಹೀಗಾಗಿ ಅಂತಿಮ ಬಿಟ್ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಒಂದು ಪಾಯಿಂಟರ್ ಕೊನೆಯಲ್ಲಿ ಬಿಟ್ಗಳು ಉದ್ದವಾಗಿದೆ.

1068
01:06:12,310 --> 01:06:17,320
ಪಾಯಿಂಟರ್ಸ್, ಹೆಚ್ಚುವರಿ ವಿಷಯಗಳು ಯಾವುದೇ ರೀತಿಯ ಜೀರ್ಣಿಸಿಕೊಳ್ಳಲು ಕಷ್ಟವಾಗುತ್ತದೆ

1069
01:06:17,320 --> 01:06:20,300
ಆದ್ದರಿಂದ ನ ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ಉದಾಹರಣೆ ಮೂಲಕ ಹೋಗಲು ಅವಕಾಶ.

1070
01:06:20,300 --> 01:06:25,130
, ಏನು ಕ್ರಿಯಾಶೀಲ ಸ್ಮರಣೆ ಹಂಚಿಕೆ ನೀವು ಮಾಡುತ್ತದೆ, ಅಥವಾ ನಾವು malloc ಕರೆಯುವ

1071
01:06:25,130 --> 01:06:29,280
ನೀವು ಸೆಟ್ ಹೊರಗಿನ ದತ್ತಾಂಶದ ಬಗೆಯ ನಿಯೋಜಿಸಿ ಅನುಮತಿಸುತ್ತದೆ.

1072
01:06:29,280 --> 01:06:31,830
ಆದ್ದರಿಂದ ಈ ಡೇಟಾವನ್ನು ರೀತಿಯ ಕಾರ್ಯಕ್ರಮದ ಕಾಲಾವಧಿಯ ಹೆಚ್ಚು ಶಾಶ್ವತ.

1073
01:06:31,830 --> 01:06:36,430
ನೀವು ತಿಳಿದಿರುವ ಕಾರಣ, ನೀವು ಒಂದು ಕಾರ್ಯದ ಒಳಗೆ X, ಮತ್ತು ಕಾರ್ಯ ಮರಳುತ್ತದೆ ಘೋಷಿಸಿದ ವೇಳೆ,

1074
01:06:36,430 --> 01:06:40,910
ನೀವು ಇನ್ನು ಮುಂದೆ X ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಮಾಹಿತಿ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ.

1075
01:06:40,910 --> 01:06:44,420
ಏನು ಪಾಯಿಂಟರ್ಸ್ ನಮಗೆ ಮಾಡಿ ಅವರು ನಮಗೆ ಮೆಮೊರಿ ಅಥವಾ ಅಂಗಡಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಅವಕಾಶ ಹೊಂದಿದೆ

1076
01:06:44,420 --> 01:06:46,840
ಅವುಗಳೆಂದರೆ ಮೆಮೊರಿಯ ಬೇರೆ ವಿಭಾಗದಲ್ಲಿ, ಹೇರಳ.

1077
01:06:46,840 --> 01:06:49,340
ಈಗ ಒಮ್ಮೆ ನಾವು ಎಲ್ಲಿಯವರೆಗೆ ನಾವು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ, ಕ್ರಿಯೆಯ ಔಟ್ ಹಿಂತಿರುಗಿ

1078
01:06:49,340 --> 01:06:54,960
ಮೆಮೊರಿ ಆ ಸ್ಥಳಕ್ಕೆ, ನಾವು ಏನು ಮಾಡಬಹುದು ನಾವು ಅಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ನೋಡಬಹುದು ಆಗಿದೆ.

1079
01:06:54,960 --> 01:06:58,020
ನ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ: ಈ ಮತ್ತೆ ನಮ್ಮ ಮೆಮೊರಿ ವಿನ್ಯಾಸ ಹೊಂದಿದೆ.

1080
01:06:58,020 --> 01:07:00,050
ಮತ್ತು ನಾವು ಮುಖ್ಯ, ಈ ಫಂಕ್ಷನ್.

1081
01:07:00,050 --> 01:07:06,870
ಏನು ಅದು ಹೊಂದಿದೆ - ಸರಿ, ಆದ್ದರಿಂದ ಸರಳ, ಬಲ - ಇಂಟ್ X = 5, ಎಂದು ಕೇವಲ ಮುಖ್ಯ ರಲ್ಲಿ ಸ್ಟಾಕ್ ಒಂದು ವೇರಿಯೇಬಲ್ ನ.

1082
01:07:06,870 --> 01:07:12,450
>> ಮತ್ತೊಂದೆಡೆ, ಈಗ ನಾವು ಕಾರ್ಯ giveMeThreeInts ಕರೆಗಳನ್ನು ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸಿದ.

1083
01:07:12,450 --> 01:07:16,800
ಆದ್ದರಿಂದ ಈಗ ನಾವು ಈ ಕಾರ್ಯವನ್ನು ಹೋಗಿ ನಾವು ಹೊಸ ಸ್ಟಾಕ್ ಫ್ರೇಮ್ ರಚಿಸಲು.

1084
01:07:16,800 --> 01:07:20,440
ಆದಾಗ್ಯೂ, ಈ ಸ್ಟಾಕ್ ಚೌಕಟ್ಟಿನಲ್ಲಿ, ನಾವು, ಇಂಟ್ * ಟೆಂಪ್ ಘೋಷಿಸಲು

1085
01:07:20,440 --> 01:07:23,210
ಇದು ನಮಗೆ mallocs 3 ಪೂರ್ಣಾಂಕಗಳ ರಲ್ಲಿ.

1086
01:07:23,210 --> 01:07:25,880
ಆದ್ದರಿಂದ ಇಂಟ್ ಗಾತ್ರವನ್ನು, ಈ ಇಂಟ್ ಎಷ್ಟು ಬೈಟ್ಗಳು ನಮಗೆ ನೀಡುತ್ತದೆ

1087
01:07:25,880 --> 01:07:29,620
ಮತ್ತು malloc ನಮಗೆ ನೀಡುವ ರಾಶಿ ಮೇಲೆ ಜಾಗ ಅನೇಕ ಬೈಟ್ಗಳು.

1088
01:07:29,620 --> 01:07:32,890
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು, 3 ಪೂರ್ಣಾಂಕಗಳ ಸಾಕಷ್ಟು ಸ್ಥಳವಿಲ್ಲ ರಚಿಸಿದ

1089
01:07:32,890 --> 01:07:36,830
ಮತ್ತು ರಾಶಿ ನಾನು ಹೆಚ್ಚಿನ ಅಪ್ ಅದನ್ನು ಡ್ರಾ ಮಾಡಿದ ಇದಕ್ಕಾಗಿಯೇ, ಅಪ್ ಅಲ್ಲಿ ಮಾರ್ಗವಾಗಿದೆ.

1090
01:07:36,830 --> 01:07:42,900
ನಾವು ಮುಗಿಸಿದ ನಂತರ, ನಾವು ಇಲ್ಲಿ ಹಿಂತಿರುಗಿ, ನೀವು ಕೇವಲ 3 ints ಮರಳಿದರು ಅಗತ್ಯವಿದೆ,

1091
01:07:42,900 --> 01:07:47,000
ಮತ್ತು ಆ ಮೆಮೊರಿ ಅಲ್ಲಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವಿಳಾಸಕ್ಕೆ ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

1092
01:07:47,000 --> 01:07:51,250
ಮತ್ತು ನಾವು ಪಾಯಿಂಟರ್ = ಸ್ವಿಚ್ ಸೆಟ್, ಮತ್ತು ಅಲ್ಲಿ ನಾವು ಮತ್ತೊಂದು ಪಾಯಿಂಟರ್ ಹೊಂದಿರುತ್ತವೆ.

1093
01:07:51,250 --> 01:07:54,550
ಆದರೆ ಯಾವ ಕ್ರಿಯೆ ಮರಳುತ್ತದೆ ಇಲ್ಲಿ ಜೋಡಿಸಲಾದ ಮತ್ತು ಕಣ್ಮರೆಯಾಗುತ್ತದೆ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.

1094
01:07:54,550 --> 01:07:59,250
ಆದ್ದರಿಂದ ಟೆಂಪ್ ಮಾಯವಾಗಿ, ಆದರೆ ನಾವು ಈಗಲೂ ಅಲ್ಲಿ ವಿಳಾಸವನ್ನು ನಿರ್ವಹಿಸಲು

1095
01:07:59,250 --> 01:08:01,850
ಆ 3 ಪೂರ್ಣಾಂಕಗಳ ಕೊಳವೆಗಳು ಒಳಭಾಗದಲ್ಲಿ.

1096
01:08:01,850 --> 01:08:06,180
ಈ ಸೆಟ್, ಪಾಯಿಂಟರ್ಸ್, ಜೋಡಿಸಲಾದ ಚೌಕಟ್ಟಿಗೆ ಸ್ಥಳೀಯವಾಗಿ ಕ್ಷೇತ್ರ ಗಳು

1097
01:08:06,180 --> 01:08:09,860
ಆದರೆ ಅವು ಉಲ್ಲೇಖಿಸಲು ಮೆಮೊರಿ ಹೇರಳ ಹೊಂದಿದೆ.

1098
01:08:09,860 --> 01:08:12,190
>> ಎಂದು ಅರ್ಥ ಡಸ್?

1099
01:08:12,190 --> 01:08:14,960
[ವಿದ್ಯಾರ್ಥಿ] ಆ ಪುನರಾವರ್ತಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ? >> [ಜೋಸೆಫ್] ಹೌದು.

1100
01:08:14,960 --> 01:08:20,270
ನಾನು ಮತ್ತೆ ಸ್ವಲ್ಪ ಹೋಗಿ ಆದ್ದರಿಂದ, ನೀವು ಟೆಂಪ್ ವಿಂಗಡಿಸುವ ನೋಡಿ

1101
01:08:20,270 --> 01:08:23,500
ಇಲ್ಲಿ ಅಪ್ ರಾಶಿ ಮೇಲೆ ಸ್ವಲ್ಪ ಮೆಮೊರಿ.

1102
01:08:23,500 --> 01:08:28,680
ಈ ಕ್ರಿಯೆ, giveMeThreeInts ಮರಳುತ್ತದೆ, ಇಲ್ಲಿ ಈ ಸ್ಟಾಕ್ ಕಣ್ಮರೆಯಾಗುತ್ತಿವೆ ಹತ್ತಿದರೆ.

1103
01:08:28,680 --> 01:08:35,819
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಸ್ಥಿರಗಳ ಯಾವುದೇ, ಜೋಡಿಸಲಾದ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಹಂಚಲಾಯಿತು ಈ ಪಾಯಿಂಟರ್.

1104
01:08:35,819 --> 01:08:39,649
ನಾವು ಟೆಂಪ್ ಮರಳಿದರು ಎಂದು ಕಣ್ಮರೆಯಾಗಿ ಹೋಗುವ, ಆದರೆ

1105
01:08:39,649 --> 01:08:46,330
ಮತ್ತು ನಾವು = ಟೆಂಪ್, ಪಾಯಿಂಟರ್ ಈಗ ತಾಪಮಾನ ಎಂದು ಸ್ಥಳ ಅದೇ ಮೆಮೊರಿ ತೋರಿಸಲು ವಿಶೇಷವೇನು ಪಾಯಿಂಟರ್ ಸೆಟ್.

1106
01:08:46,330 --> 01:08:50,370
ಈಗ, ನಾವು ಟೆಂಪ್, ಸ್ಥಳೀಯ ಪಾಯಿಂಟರ್, ಕಳೆದುಕೊಳ್ಳಲು ಕೂಡ

1107
01:08:50,370 --> 01:08:59,109
ನಾವು ಈಗಲೂ ಆ ವೇರಿಯಬಲ್ ಪಾಯಿಂಟರ್ ಒಳಗೆ ತೋರುತ್ತಿರುವಂತೆ ಏನು ನೆನಪಿಗಾಗಿ ವಿಳಾಸಕ್ಕೆ ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ.

1108
01:08:59,109 --> 01:09:03,740
ಪ್ರಶ್ನೆಗಳು? ನೀವು ವಿಭಾಗದಲ್ಲಿ ಅದನ್ನು ಹೋದ ಇದ್ದರೆ ಒಂದು ಗೊಂದಲಮಯ ವಿಷಯ ರೀತಿಯ ಮಾಡಬಹುದು.

1109
01:09:03,740 --> 01:09:09,240
ನಾವು, ನಿಮ್ಮ TF ಖಂಡಿತವಾಗಿಯೂ ಅದನ್ನು ಹೋಗುತ್ತದೆ ಮತ್ತು ಸಹಜವಾಗಿ ನಾವು ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತರಿಸುವಿರೆ

1110
01:09:09,240 --> 01:09:11,500
ಈ ರಿವ್ಯೂ ಅಧಿವೇಶನದ ಕೊನೆಯಲ್ಲಿ.

1111
01:09:11,500 --> 01:09:14,220
ಆದರೆ ಈ ಸಂಕೀರ್ಣ ವಿಷಯದ ತೆರನಾದ, ಮತ್ತು ನಾನು ತೋರಿಸುತ್ತವೆ ಹೋಗುವವರು ಹೆಚ್ಚು ಉದಾಹರಣೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ

1112
01:09:14,220 --> 01:09:18,790
ಆ ಪಾಯಿಂಟರ್ಸ್ ವಾಸ್ತವವಾಗಿ ಯಾವ ಸ್ಪಷ್ಟನೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.

1113
01:09:18,790 --> 01:09:22,500
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪಾಯಿಂಟರ್ಸ್, ಸರಣಿಗಳ ಸಮನಾಗಿದೆ

1114
01:09:22,500 --> 01:09:25,229
ಆದ್ದರಿಂದ ನಾನು ಒಂದು ಇಂಟ್ ಸರಣಿ ಅದೇ ವಿಷಯ ಈ ಪಾಯಿಂಟರ್ ಬಳಸಬಹುದು.

1115
01:09:25,229 --> 01:09:29,840
ಹಾಗಾಗಿ, 0 ಗೆ ಸೂಚಿ, ಮತ್ತು 1 ಮೊದಲ ಪೂರ್ಣಾಂಕ ಬದಲಾಗುತ್ತಿರುವ ನಾನು

1116
01:09:29,840 --> 01:09:39,689
2 ಎರಡನೇ ಪೂರ್ಣಾಂಕ ಬದಲಾಯಿಸುವ, ಮತ್ತು 3 ನೇ ಪೂರ್ಣಾಂಕ 3.

1117
01:09:39,689 --> 01:09:44,210
ಪಾಯಿಂಟರ್ಸ್ ಹಾಗೆ ಹೆಚ್ಚು. ಅಲ್ಲದೆ, Binky ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ.

1118
01:09:44,210 --> 01:09:48,319
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಮಂಜೂರು ಮಾಡಿದ, ಅಥವಾ ನಾವು ಒಂದು ಪಾಯಿಂಟರ್ ಡಿಕ್ಲೇರ್ಡ್

1119
01:09:48,319 --> 01:09:52,760
ಆದರೆ ಆರಂಭದಲ್ಲಿ, ನಾನು ಒಂದು ಪಾಯಿಂಟರ್ ಘೋಷಿಸಿತು, ಇದು ನಗರದಲ್ಲಿ ನೆನಪಿಗಾಗಿ ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲ.

1120
01:09:52,760 --> 01:09:54,930
ಇದು ಒಳಗೆ ಕೇವಲ ತ್ಯಾಜ್ಯವೇ ಮೌಲ್ಯಗಳನ್ನು ಇಲ್ಲಿದೆ.

1121
01:09:54,930 --> 01:09:56,470
ಆದ್ದರಿಂದ ನಾನು ಈ ಪಾಯಿಂಟರ್ ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲಿ ಕಲ್ಪನೆಯೂ ಇಲ್ಲ.

1122
01:09:56,470 --> 01:10:01,630
ಇದು ಕೇವಲ 0 ಮತ್ತು 1 ರ ಆರಂಭದಲ್ಲಿ ಘೋಷಿಸಲಾಯಿತು ಅಲ್ಲಿ ತುಂಬಿ ಒಂದು ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ.

1123
01:10:01,630 --> 01:10:04,810
ನಾನು malloc ಕರೆ ತನಕ ನಾನು ಏನನ್ನೂ ಮಾಡಬಹುದು

1124
01:10:04,810 --> 01:10:08,390
ಮತ್ತು ನಂತರ ನಾನು ಒಳಗೆ ಮೌಲ್ಯಗಳನ್ನು ಹಾಕಬಹುದು ಅಲ್ಲಿ ರಾಶಿ ಮೇಲೆ ಸ್ವಲ್ಪ ಜಾಗವನ್ನು ನೀಡುತ್ತದೆ.

1125
01:10:08,390 --> 01:10:11,980
ನಂತರ, ಈ ಮೆಮೊರಿಯ ಒಳಗೆ ಎಂಬುದನ್ನು ತಿಳಿದಿಲ್ಲ.

1126
01:10:11,980 --> 01:10:16,780
ಆದ್ದರಿಂದ ನಾನು ಮಾಡಬೇಕು ಮೊದಲ ವಿಷಯ ವ್ಯವಸ್ಥೆಯನ್ನು ಸಾಕಷ್ಟು ಮೆಮೊರಿಯನ್ನು ಹೊಂದಿತ್ತು ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ ಆಗಿದೆ

1127
01:10:16,780 --> 01:10:20,850
ನಾನು ಈ ಪರಿಶೀಲಿಸಿ ಮಾಡುತ್ತಿರುವೆ ಏಕೆ ಇದು ಮೊದಲ ಸ್ಥಳದಲ್ಲಿ 1 ಪೂರ್ಣಾಂಕ ಮರಳಿ ನೀಡಲು.

1128
01:10:20,850 --> 01:10:25,020
ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ವೇಳೆ, ಅದು ಸಾಕಷ್ಟು ಜಾಗವನ್ನು ಅಥವಾ ಕೆಲವು ಇತರ ದೋಷ ಸಂಭವಿಸಿದೆ ಹೊಂದಿಲ್ಲ ಎಂದರ್ಥ

1129
01:10:25,020 --> 01:10:26,320
ಆದ್ದರಿಂದ ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಔಟ್ ನಿರ್ಗಮಿಸಲು ಮಾಡಬೇಕು.

1130
01:10:26,320 --> 01:10:29,400
 ಯಶಸ್ವಿಗೊಳ್ಳಲು ಮಾಡಿದರೆ ಆದರೆ, ಈಗ ನಾನು ಪಾಯಿಂಟರ್ ಬಳಸಬಹುದು

1131
01:10:29,400 --> 01:10:35,020
ಮತ್ತು * ಪಾಯಿಂಟರ್ ಮಾಡುತ್ತದೆ ವಿಳಾಸಕ್ಕೆ ಅಲ್ಲಿ ಅದು ಈ ರೀತಿ ಇರುತ್ತದೆ

1132
01:10:35,020 --> 01:10:38,480
ಅಲ್ಲಿ ಆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಇದು 1 ಗೆ ಸಮಾನ ಸೆಟ್ಸ್.

1133
01:10:38,480 --> 01:10:41,850
ಆ ಮೆಮೊರಿ ಅಸ್ತಿತ್ವದಲ್ಲಿತ್ತು ವೇಳೆ ಇಲ್ಲಿ ಮೇಲೆ ನಾವು ಪರಿಶೀಲಿಸುತ್ತಿದ್ದೇವೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

1134
01:10:41,850 --> 01:10:45,380
>> ನೀವು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ತಿಳಿಯಲು ಒಮ್ಮೆ ಇದನ್ನು ಇರಿಸಬಹುದು

1135
01:10:45,380 --> 01:10:50,460
ಯಾವ ಮೌಲ್ಯವನ್ನು ನೀವು ಜಾರಿಗೆ ಬಯಸುವ; ಈ ಸಂದರ್ಭದಲ್ಲಿ 1 ರಲ್ಲಿ.

1136
01:10:50,460 --> 01:10:53,060
ನಾವು ಇದನ್ನು ಮುಗಿಸಿದ ನಂತರ, ನೀವು ಎಂದು ಪಾಯಿಂಟರ್ ಮುಕ್ತಗೊಳಿಸಲು ಅಗತ್ಯವಿದೆ

1137
01:10:53,060 --> 01:10:57,160
ನಾವು ವ್ಯವಸ್ಥೆಯನ್ನು ನೀವು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಕೇಳಿದ ಆ ಮೆಮೊರಿ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತದೆ ಬೇಕಾಗುತ್ತದೆ.

1138
01:10:57,160 --> 01:10:59,690
ಏಕೆಂದರೆ ಕಂಪ್ಯೂಟರ್ ನಾವು ಪೂರೈಸಿದ ಮೇಲೆ ಗೊತ್ತಿಲ್ಲ.

1139
01:10:59,690 --> 01:11:02,510
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳುತ್ತವೆ, ಸರಿ, ನಾವು ಮೆಮೊರಿ ಪೂರೈಸಿದ.

1140
01:11:02,510 --> 01:11:10,780
ಕೆಲವು ಇತರ ಪ್ರಕ್ರಿಯೆಯ ಇದು ಅಗತ್ಯವಿದ್ದರೆ, ಕೆಲವು ಇತರ ಪ್ರೋಗ್ರಾಂ ಅದು ಅಗತ್ಯವಿದೆ, ಮುಂದೆ ಹೋಗಿ ಅದನ್ನು ಪಡೆಯಲು ಹಿಂಜರಿಯಬೇಡಿ.

1141
01:11:10,780 --> 01:11:15,110
ನಾವು ಕೂಡ ಮಾಡಬಹುದು ನಾವು ಸೆಟ್ನಲ್ಲಿ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳ ವಿಳಾಸಕ್ಕೆ ಗಳಿಸುತ್ತಿದ್ದರು.

1142
01:11:15,110 --> 01:11:19,080
ಆದ್ದರಿಂದ ಇಂಟ್ X ಮುಖ್ಯ ಜೋಡಿಸಲಾದ ಫ್ರೇಮ್ ಒಳಗಿದೆ.

1143
01:11:19,080 --> 01:11:23,060
ಮತ್ತು ನಾವು ಈ ವನ್ನಾಗಲಿ ಬಳಸಿದಾಗ, ಈ ಮತ್ತು ಆಯೋಜಕರು, ಏನು ಅದು ಹೊಂದಿದೆ

1144
01:11:23,060 --> 01:11:27,310
ಇದು X ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಮತ್ತು X ಮೆಮೊರಿ ಕೇವಲ ಕೆಲವು ಡೇಟಾವನ್ನು ಹೊಂದಿದೆ, ಆದರೆ ಇದು ಒಂದು ವಿಳಾಸವನ್ನು ಹೊಂದಿಲ್ಲ.

1145
01:11:27,310 --> 01:11:33,790
ಇದು ಎಲ್ಲೋ ಇದೆ ಮಾಡಿದ. ಈ ಏನು ಕರೆ & X, ನಿಂದ ಆದ್ದರಿಂದ ನಮಗೆ X ವಿಳಾಸವನ್ನು ನೀಡುತ್ತದೆ.

1146
01:11:33,790 --> 01:11:38,430
ಹೀಗೆ ಮಾಡುವುದರ ಮೂಲಕ, ನಾವು X ನೆನಪಿಗಾಗಿ ಅಲ್ಲಿ ಸೂಚಕವನ್ನು ಪಾಯಿಂಟ್ ನೀವು ಮಾಡುತ್ತಿರುವಿರಿ.

1147
01:11:38,430 --> 01:11:41,710
ಈಗ ನಾವು * ನಂತೆ X, ನಾವು 5 ಮರಳಿ ಪಡೆಯಲು ನೀನು ಇಲ್ಲ.

1148
01:11:41,710 --> 01:11:43,820
ನಕ್ಷತ್ರ ಇದು dereferencing ಕರೆಯಲಾಗುತ್ತದೆ.

1149
01:11:43,820 --> 01:11:46,640
ನೀವು ವಿಳಾಸಕ್ಕೆ ಅನುಸರಿಸಲು ಮತ್ತು ನೀವು ಸಂಗ್ರಹಿಸಿದ ಅದು ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು.

1150
01:11:51,000 --> 01:11:53,310
>> ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು? ಹೌದು?

1151
01:11:53,310 --> 01:11:56,500
ನೀವು 3 ಚೂಪಾದ ವಸ್ತು ಮಾಡದಿದ್ದರೆ [ವಿದ್ಯಾರ್ಥಿ], ಇದು ಇನ್ನೂ ಕಂಪೈಲ್ ಮಾಡುವುದಿಲ್ಲ?

1152
01:11:56,500 --> 01:11:59,490
ಹೌದು. ನೀವು 3 ಪಾಯಿಂಟರ್ ವಿಷಯ ಮಾಡದಿದ್ದರೆ, ಇದು ಈಗಲೂ ಸಂಕಲಿಸಲು ವಿಶೇಷವೇನು

1153
01:11:59,490 --> 01:12:02,720
ಆದರೆ, ಎರಡನೇ ನಡೆಯುವ ನೀವು ತೋರಿಸಲು, ಮತ್ತು ಕೈಗೊಳ್ಳದೆ ವಿಲ್

1154
01:12:02,720 --> 01:12:04,860
ನಾವು ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಕರೆಯುವ ಇಲ್ಲಿದೆ. ನೀವು ವ್ಯವಸ್ಥೆಯನ್ನು ನೀಡುವ ಇಲ್ಲ

1155
01:12:04,860 --> 01:12:07,850
ಅದರ ಮೆಮೊರಿ ಬ್ಯಾಕ್, ಆದ್ದರಿಂದ ಒಂದು ನಂತರ ಪ್ರೋಗ್ರಾಂ ಕೂಡಿಕೊಂಡು ಹೋಗಿ ಹಾಗೆಯೇ

1156
01:12:07,850 --> 01:12:10,940
ಇದು ಬಳಸುವ, ಮತ್ತು ಮತ್ತೇನಲ್ಲ ಬಳಸಬಹುದು ಮೆಮೊರಿ ಆ.

1157
01:12:10,940 --> 01:12:15,750
ನೀವು ಎಂದಾದರೂ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ನಲ್ಲಿ 1.5 ಮಿಲಿಯನ್ ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ಜೊತೆ ಫೈರ್ಫಾಕ್ಸ್ ನೋಡಿದ ವೇಳೆ,

1158
01:12:15,750 --> 01:12:17,840
ಕಾರ್ಯ ನಿರ್ವಾಹಕ ರಲ್ಲಿ, ಎಂದು ಇಂದಿನ ವಿಶೇಷವೇನು ಇಲ್ಲಿದೆ.

1159
01:12:17,840 --> 01:12:20,760
ಅವರು ನಿಭಾಯಿಸಲು ಎಂಬುದಾಗಿ ನೀವು ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ.

1160
01:12:23,080 --> 01:12:26,240
ಆದ್ದರಿಂದ ಹೇಗೆ ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ?

1161
01:12:26,240 --> 01:12:29,480
ಅಲ್ಲದೆ, ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಆಗಿ ಮುಂತಾದ ಅನುಕ್ರಮಣಿಕೆ ರೀತಿಯ ಹೊಂದಿದೆ.

1162
01:12:29,480 --> 01:12:36,370
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಪಾಯಿಂಟರ್ ಹೊಂದಿವೆ, ಮತ್ತು ನಾನು ನನ್ನ ಮೊದಲ ಅಂಶ ಸೂಚಕವನ್ನು ಪಾಯಿಂಟ್ ಮಾಡಿ ಆಗಿದೆ

1163
01:12:36,370 --> 01:12:42,100
ನಾನು ನಿಯೋಜಿತವಾದ ಎಂಬುದನ್ನು 3 ಪೂರ್ಣಾಂಕಗಳ ಈ ರಚನೆಯ.

1164
01:12:42,100 --> 01:12:46,670
ಈಗ ನಾನು ಏನು, ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್ ಕೇವಲ ಪಟ್ಟಿಯಲ್ಲಿ ಮೊದಲ ಅಂಶ ಬದಲಾಯಿಸುತ್ತದೆ.

1165
01:12:46,670 --> 01:12:49,140
ಇಲ್ಲಿ ಮೇಲೆ ಸ್ಟಾರ್ ಪಾಯಿಂಟರ್ +1 ಅಂಕಗಳನ್ನು.

1166
01:12:49,140 --> 01:12:53,140
ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ ಇಲ್ಲಿ ಸುಮಾರು, ಪಾಯಿಂಟರ್ +1 ಇಲ್ಲಿ ಸುಮಾರು, ಪಾಯಿಂಟರ್ +2 ಇಲ್ಲಿ ಮುಗಿದ.

1167
01:12:53,140 --> 01:12:56,610
>> ಆದ್ದರಿಂದ ಕೇವಲ 1 ಸೇರಿಸುವ ಈ ರಚನೆಯ ಉದ್ದಕ್ಕೂ ಚಲಿಸುತ್ತಿರುವ ಅದೇ ವಿಷಯ.

1168
01:12:56,610 --> 01:12:59,880
ನಾವು ಏನು ಆಗಿದೆ, ನಾವು ಪಾಯಿಂಟರ್ +1 ಮಾಡಿದಾಗ ನೀವು ಇಲ್ಲಿ ಮೇಲೆ ವಿಳಾಸವನ್ನು ಪಡೆಯಲು

1169
01:12:59,880 --> 01:13:04,180
ಮತ್ತು ಇಲ್ಲಿ ಮೌಲ್ಯ ಪಡೆಯುವ ಸಲುವಾಗಿ, ನೀವು ಸಂಪೂರ್ಣ ನಿರೂಪಣೆಯಿಂದ ಒಂದು ಸ್ಟಾರ್ ಪುಟ್

1170
01:13:04,180 --> 01:13:05,990
ಇದು dereference ಗೆ.

1171
01:13:05,990 --> 01:13:09,940
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು, 1 ಈ ರಚನೆಯ ಮೊದಲ ಸ್ಥಳ ಹೊಂದಿಸುವ ನಾನು

1172
01:13:09,940 --> 01:13:13,970
2 ಎರಡನೇ ಸ್ಥಳ, ಮತ್ತು 3 ಮೂರನೇ ಸ್ಥಳ.

1173
01:13:13,970 --> 01:13:18,180
ನಂತರ ಏನು ನಾನು ಇಲ್ಲಿ ಮೇಲೆ ಮಾಡುತ್ತಿರುವೆ, ನಾನು ನಮ್ಮ ಪಾಯಿಂಟರ್ +1 ಮುದ್ರಿಸುವ ನನಗೆ

1174
01:13:18,180 --> 01:13:19,970
ಇದು ನನಗೆ 2 ನೀಡುತ್ತದೆ.

1175
01:13:19,970 --> 01:13:23,650
ಈಗ, ನಾನು ಪಾಯಿಂಟರ್ ಏರಿಕೆಯ ಭಾವಿಸುತ್ತೇನೆ, ಆದ್ದರಿಂದ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟರ್ +1 ಸಮನಾಗಿರುತ್ತದೆ

1176
01:13:23,650 --> 01:13:26,780
ಇದು ಮುಂದೆ ಇದು ಚಲಿಸುತ್ತದೆ.

1177
01:13:26,780 --> 01:13:30,810
ಆದ್ದರಿಂದ ಈಗ ನಾನು ಪಾಯಿಂಟರ್ +1 ಮುದ್ರಿಸುತ್ತದೆ ವೇಳೆ, ಪಾಯಿಂಟರ್ +1, ಈಗ 3

1178
01:13:30,810 --> 01:13:33,990
ಈ ಸಂದರ್ಭದಲ್ಲಿ 3 ಔಟ್ ಮುದ್ರಿಸುತ್ತದೆ.

1179
01:13:33,990 --> 01:13:36,560
ಮತ್ತು ಉಚಿತ ಏನೋ, ನಾನು ನೀಡುವ ಪಾಯಿಂಟರ್ ಸಲುವಾಗಿ

1180
01:13:36,560 --> 01:13:40,540
ನಾನು malloc ಮರಳಿ ಪಡೆದುಕೊಂಡರು ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಮಾಡಬೇಕು.

1181
01:13:40,540 --> 01:13:43,430
ನಾನು ಇಲ್ಲಿ 3 ಕರೆಯಲು ವೇಳೆ ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ, ಬಲ ನೆರವೇರಿಸಲಾಯಿತು

1182
01:13:43,430 --> 01:13:45,070
ಇದು ರಚನೆಯ ಮಧ್ಯದಲ್ಲಿ ಏಕೆಂದರೆ.

1183
01:13:45,070 --> 01:13:48,820
ನಾನು ಮೂಲ ಸ್ಥಳ ಪಡೆಯಲು ಕಳೆಯುವುದು ಹೊಂದಿವೆ

1184
01:13:48,820 --> 01:13:50,420
ನಾನು ಮುಕ್ತಗೊಳಿಸಲು ಮೊದಲು ಆರಂಭಿಕ ಮೊದಲ ಸ್ಥಾನ.

1185
01:13:56,300 --> 01:13:58,450
ಆದ್ದರಿಂದ, ಇಲ್ಲಿ ಹೆಚ್ಚು ಒಳಗೊಂಡಿತ್ತು ಉದಾಹರಣೆ.

1186
01:13:58,450 --> 01:14:03,360
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಒಂದು ಪಾತ್ರ ಶ್ರೇಣಿಯಲ್ಲಿನ 7 ಪಾತ್ರಗಳು ಹಂಚುತ್ತಾರೆ ಮಾಡುತ್ತಿದ್ದೇವೆ.

1187
01:14:03,360 --> 01:14:06,480
>> ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಆಲ್ಬಮ್ನಲ್ಲಿ ಏನು, ನಾವು ಅವರನ್ನು ಮೊದಲ 6 ಮೇಲೆ ಲೂಪ್ ನೀವು ಆಗಿದೆ

1188
01:14:06,480 --> 01:14:09,900
ಮತ್ತು ನಾವು ಝಡ್ ಅವರನ್ನು ಹೊಂದಿಸುವಾಗ ನೀವು

1189
01:14:09,900 --> 01:14:13,350
ಆದ್ದರಿಂದ, ಇಂಟ್ ನಾನು = 0, ನಾನು> 6, ನಾನು + +

1190
01:14:13,350 --> 01:14:16,220
ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ + ನಾನು, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಮಗೆ ನೀಡುತ್ತದೆ

1191
01:14:16,220 --> 01:14:20,860
ಪಾಯಿಂಟರ್, ಪಾಯಿಂಟರ್ +1, ಪಾಯಿಂಟರ್ +2, ಪಾಯಿಂಟರ್ +3, ಹೀಗೆ ಇತ್ಯಾದಿ ಚಕ್ರಕ್ಕೆ.

1192
01:14:20,860 --> 01:14:24,040
ಏನು ಮಾಡಲು ವಿಶೇಷವೇನು, ಅದು ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು, dereferences ಎಂದು ವಿಳಾಸಕ್ಕೆ ಗೆಟ್ಸ್ ಆಗಿದೆ

1193
01:14:24,040 --> 01:14:27,440
ಒಂದು ಝಡ್ ಮತ್ತು ಬದಲಾವಣೆಗಳನ್ನು ಮೌಲ್ಯ

1194
01:14:27,440 --> 01:14:30,350
ನಂತರ ಕೊನೆಯಲ್ಲಿ ಹಕ್ಕನ್ನು, ಈ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿದೆ ನೆನಪಿಡಿ?

1195
01:14:30,350 --> 01:14:33,560
ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಅಕ್ಷರದೊಂದಿಗೆ ಅಂತ್ಯಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

1196
01:14:33,560 --> 01:14:38,620
ಆದ್ದರಿಂದ, ನಾನು ಏನನ್ನು ಪಾಯಿಂಟರ್ 6 ನಾನು ಸೈನ್ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಪಾತ್ರ ಹಾಕಲಾಗುತ್ತದೆ

1197
01:14:38,620 --> 01:14:43,980
ಮತ್ತು ಈಗ ನಾನು ಮೂಲತಃ ಇಲ್ಲಿ ಮೇಲೆ ಏನು ಮಾಡುತ್ತಿರುವೆ, ಒಂದು ತಂತಿಗೆ printf ಬಲ ಅನುಷ್ಠಾನಕ್ಕೆ ಇದೆ?

1198
01:14:43,980 --> 01:14:46,190
>> ಆದ್ದರಿಂದ, ಯಾವಾಗ printf ಈಗ ಸ್ಟ್ರಿಂಗ್ ಕೊನೆಯಲ್ಲಿ ತಲುಪಿದ್ದೇನೆ ಅದು?

1199
01:14:46,190 --> 01:14:48,230
ಇದು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಪಾತ್ರ ಬಡಿದಾಗ.

1200
01:14:48,230 --> 01:14:52,030
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ನನ್ನ ಮೂಲ ಪಾಯಿಂಟರ್ ಅಂಕಗಳನ್ನು.

1201
01:14:52,030 --> 01:14:56,410
ನಾನು ಮೊದಲ ಅಕ್ಷರ ಮುದ್ರಿಸುತ್ತದೆ. ನಾನು ಮೇಲೆ ಅದನ್ನು ಸರಿಸಲು.

1202
01:14:56,410 --> 01:14:58,420
ನಾನು ಆ ಪಾತ್ರವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ನಾನು ಮೇಲೆ ಸರಿಸಲು.

1203
01:14:58,420 --> 01:15:02,180
ಮತ್ತು ನಾನು ಕೊನೆಯಲ್ಲಿ ತಲುಪುವವರೆಗೆ ಈ ನಡೆಸುವ.

1204
01:15:02,180 --> 01:15:07,750
ಈಗ ಕೊನೆಯಲ್ಲಿ * ಪಾಯಿಂಟರ್ ತಿನ್ನುವೆ dereference ಈ ಮತ್ತು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಪಾತ್ರವನ್ನು ಹಿಂದೆ.

1205
01:15:07,750 --> 01:15:11,780
ಆದ್ದರಿಂದ ನನ್ನ ಸಮಯದಲ್ಲಿ ಲೂಪ್ ಎಂದು ಮೌಲ್ಯವನ್ನು ಶೂನ್ಯ ಕೊನೆಗೊಳಿಸುವ ಅಕ್ಷರವಾಗಿದೆ ಮಾತ್ರ ಚಲಿಸುತ್ತದೆ.

1206
01:15:11,780 --> 01:15:13,770
ಆದ್ದರಿಂದ, ಈಗ ನಾನು ಈ ಕುಣಿಕೆಯಿಂದ ಹೊರಗೆ ನಿರ್ಗಮಿಸಲು.

1207
01:15:18,780 --> 01:15:21,180
ಮತ್ತು ನಾನು ಈ ಪಾಯಿಂಟರ್ 6 ಕಳೆಯಿರಿ ವೇಳೆ

1208
01:15:21,180 --> 01:15:22,860
ನಾನು ಮರಳಿ ಆರಂಭಿಸಿ ಎಲ್ಲಾ ರೀತಿಯಲ್ಲಿ ಹೋಗಿ.

1209
01:15:22,860 --> 01:15:27,880
ನಾನು ಮುಕ್ತವಾಗಿಸುವುದೇ ಆರಂಭಕ್ಕೆ ಹೋಗಲು ಏಕೆಂದರೆ ನೆನಪಿಡಿ, ನಾನು ಈ ಮಾಡುತ್ತಿರುವೆ.

1210
01:15:27,880 --> 01:15:30,270
>> ಆದ್ದರಿಂದ, ನಾನು ಒಂದು ಸಾಕಷ್ಟು ಗೊತ್ತಿರಲಿಲ್ಲ. ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಇವೆ?

1211
01:15:30,270 --> 01:15:31,870
ದಯವಿಟ್ಟು, ಹೌದು?

1212
01:15:31,870 --> 01:15:36,610
[ವಿದ್ಯಾರ್ಥಿ ಪ್ರಶ್ನೆಗೆ ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ]

1213
01:15:36,610 --> 01:15:38,190
ನೀವು ಜೋರಾಗಿ ಎಂದು ಹೇಳಬಹುದು? ಕ್ಷಮಿಸಿ.

1214
01:15:38,190 --> 01:15:44,140
[ವಿದ್ಯಾರ್ಥಿ] ನೀವು ಪಾಯಿಂಟರ್ ಬಿಡುಗಡೆ ಬಲ ಮೊದಲು ಕೊನೆಯ ಸ್ಲೈಡ್ ರಂದು,

1215
01:15:44,140 --> 01:15:47,300
ಅಲ್ಲಿ ನೀವು ವಾಸ್ತವವಾಗಿ ಪಾಯಿಂಟರ್ ಮೌಲ್ಯವನ್ನು ಬದಲಾಗುತ್ತಿರುವ?

1216
01:15:47,300 --> 01:15:50,370
[ಜೋಸೆಫ್] ಆದ್ದರಿಂದ, ಇಲ್ಲಿಯೇ. >> [ವಿದ್ಯಾರ್ಥಿ] ಓಹ್, ಸರಿ.

1217
01:15:50,370 --> 01:15:51,890
[ಜೋಸೆಫ್] ಆದ್ದರಿಂದ, ನಾನು, ಒಂದು ಪಾಯಿಂಟರ್ ಮೈನಸ್ ಮೈನಸ್ ಹೊಂದಿವೆ,

1218
01:15:51,890 --> 01:15:54,140
ಇದು, ನಾನು ಕ್ಲಿಕ್ ನಂತರ ಒಂದು ವಿಷಯ ಚಲಿಸುತ್ತದೆ, ಮತ್ತು

1219
01:15:54,140 --> 01:15:57,000
ಈ ಪಾಯಿಂಟರ್ ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ತೋರಿಸಿದರು ಮಾಡಬೇಕು ಏಕೆಂದರೆ.

1220
01:15:57,000 --> 01:16:00,420
ನೀವು ಆ ಸಾಲಿನಲ್ಲಿ ನಂತರ ನಿಲ್ಲಿಸಿದ [ವಿದ್ಯಾರ್ಥಿ] ಆದರೆ ಅಗತ್ಯವಿದೆ ಎಂದು.

1221
01:16:00,420 --> 01:16:03,130
ಈ ನಂತರ ನಿಲ್ಲಿಸಿದ ವೇಳೆ [ಜೋಸೆಫ್] ಆದ್ದರಿಂದ,, ಈ, ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ

1222
01:16:03,130 --> 01:16:04,810
ನಾನು ಮುಕ್ತ ರನ್ ಕಾರಣ.

1223
01:16:04,810 --> 01:16:11,290
[ವಿದ್ಯಾರ್ಥಿ] ನಾನು [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ನೀವು ಪಾಯಿಂಟರ್ +1 [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಹೊಂದಿತ್ತು ಅಲ್ಲಿ ಮೊದಲ ಮೂರು ಸಾಲುಗಳು ನಂತರ.

1224
01:16:11,290 --> 01:16:13,140
[ಜೋಸೆಫ್] ಹುಂ. ಆದ್ದರಿಂದ ಪ್ರಶ್ನೆ ಇಲ್ಲಿದೆ?

1225
01:16:13,140 --> 01:16:14,780
ಕ್ಷಮಿಸಿ. ಇಲ್ಲ, ಇಲ್ಲ. ದಯವಿಟ್ಟು, ಹೋಗಿ ಹೋಗಿ.

1226
01:16:14,780 --> 01:16:16,870
[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ, ನೀವು ಪಾಯಿಂಟರ್ಸ್ ಮೌಲ್ಯವನ್ನು ಬದಲಾವಣೆ ಇಲ್ಲ.

1227
01:16:16,870 --> 01:16:19,130
ನೀವು ಪಾಯಿಂಟರ್ ಮೈನಸ್ ಮೈನಸ್ ಮಾಡಲೇಬೇಕಿತ್ತು ಮಾಡಿರಲಿಲ್ಲ.

1228
01:16:19,130 --> 01:16:19,730
[ಜೋಸೆಫ್] ಹೌದು, ನಿಖರವಾಗಿ.

1229
01:16:19,730 --> 01:16:21,890
ಆದ್ದರಿಂದ, ನಾನು ಪಾಯಿಂಟರ್ +1 ಮತ್ತು ಪಾಯಿಂಟರ್ +2 ಮಾಡಿದಾಗ,

1230
01:16:21,890 --> 01:16:24,410
ನಾನು ಪಾಯಿಂಟರ್ ಮಾಡುವುದರಿಂದ ಇಲ್ಲ ಪಾಯಿಂಟರ್ +1 ಸಮನಾಗಿರುತ್ತದೆ.

1231
01:16:24,410 --> 01:16:27,260
ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ ಕೇವಲ ರಚನೆಯ ಆರಂಭದಲ್ಲಿ ತೋರುಗಡ್ಡಿ ಆಗಿರುತ್ತದೆ.

1232
01:16:27,260 --> 01:16:31,460
ನಾನು ಜೊತೆಗೆ ಮಾಡಿದಾಗ ಇದು ಮಾತ್ರ ಜೊತೆಗೆ ಇದು ಪಾಯಿಂಟರ್ ಒಳಗೆ ಮತ್ತೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ

1233
01:16:31,460 --> 01:16:33,550
ಇದು ವಾಸ್ತವವಾಗಿ ಉದ್ದಕ್ಕೂ ಈ ಚಲಿಸುವ.

1234
01:16:36,860 --> 01:16:37,780
ಎಲ್ಲಾ ಸರಿ.

1235
01:16:40,550 --> 01:16:42,030
ಹೆಚ್ಚು ಪ್ರಶ್ನೆಗಳು?

1236
01:16:44,680 --> 01:16:47,790
>> ಈ ಅಗಾಧ ರೀತಿಯ ವೇಳೆ ಮತ್ತೆ, ಈ ಅಧಿವೇಶನದಲ್ಲಿ ರಕ್ಷಣೆಯನ್ನು ಕಾಣಿಸುತ್ತದೆ.

1237
01:16:47,790 --> 01:16:50,710
ಅದರ ಬಗ್ಗೆ ನಿಮ್ಮ ಇತರ ಸಹ ಕೇಳಿ, ಮತ್ತು ನಾವು ಕೊನೆಯಲ್ಲಿ ಪ್ರಶ್ನೆಗಳನ್ನು ಉತ್ತರಿಸಬಹುದು.

1238
01:16:53,510 --> 01:16:56,600
ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಈ ಮೈನಸ್ ವಿಷಯವನ್ನು ಬಯಸುವುದಿಲ್ಲ.

1239
01:16:56,600 --> 01:16:59,760
ಈ ನಾನು ಶ್ರೇಣಿಯಲ್ಲಿನ ಆಫ್ಸೆಟ್ ನೀವು ಎಷ್ಟು ಗಮನವಿಡುತ್ತಾ ಅಗತ್ಯ ಹೊಂದಿದೆ.

1240
01:16:59,760 --> 01:17:04,520
ಆದ್ದರಿಂದ, ಸಾಮಾನ್ಯವಾಗಿ, ಈ ಪಾಯಿಂಟರ್ ಅಂಕಗಣಿತದ ಕೃತಿಗಳು ಹೇಗೆ ವಿವರಿಸಲು ಕೇವಲ ಹೊಂದಿದೆ.

1241
01:17:04,520 --> 01:17:07,970
ಆದರೆ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಮಾಡಲು ನಮಗೂ ಪಾಯಿಂಟರ್ ಪ್ರತಿಯನ್ನು ರಚಿಸಲು ಇರುತ್ತದೆ

1242
01:17:07,970 --> 01:17:11,640
ನಾವು ಸಾಲಿನಲ್ಲಿ ಸಂಚರಿಸುವ ಮಾಡಿದಾಗ ಮತ್ತು ನಂತರ ನಾವು ನಕಲನ್ನು ಬಳಸಿ.

1243
01:17:11,640 --> 01:17:14,660
ಆದ್ದರಿಂದ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು ನಕಲು, ಇಡೀ ಸ್ಟ್ರಿಂಗ್ ಮುದ್ರಿಸಲು ಬಳಸುವ

1244
01:17:14,660 --> 01:17:19,040
ಆದರೆ, ಪಾಯಿಂಟರ್ ಮೈನಸ್ 6 ಹಾಗೆ ಮಾಡಬೇಕು ಅಥವಾ ನಾವು ಈ ಬಂದು ಎಷ್ಟು ಟ್ರ್ಯಾಕ್ ಇಲ್ಲ

1245
01:17:19,040 --> 01:17:22,700
ನಾವು ನಮ್ಮ ಮೂಲ ಪಾಯಿಂಟ್ ಇನ್ನೂ ಪಟ್ಟಿಯಲ್ಲಿ ಆರಂಭದಲ್ಲಿ ತೋರಿಸಿದರು ಎಂದು ತಿಳಿದಿರುವ ಕಾರಣ

1246
01:17:22,700 --> 01:17:25,340
ಮತ್ತು ನಾವು ಮಾರ್ಪಡಿಸಿದವು ಈ ಪ್ರತಿಯನ್ನು ಆಗಿತ್ತು.

1247
01:17:25,340 --> 01:17:28,250
ಆದ್ದರಿಂದ, ಸಾಮಾನ್ಯವಾಗಿ, ನಿಮ್ಮ ಮೂಲ ಪಾಯಿಂಟರ್ ಪ್ರತಿಗಳನ್ನು ಮಾರ್ಪಡಿಸುತ್ತದೆ.

1248
01:17:28,250 --> 01:17:32,350
ತರಹದ ವಿಂಗಡಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಮಾಡಬೇಡಿ - ಮೂಲ ಪ್ರತಿಗಳು ಮಾರ್ಪಡಿಸುತ್ತದೆ don't.

1249
01:17:32,350 --> 01:17:35,290
ನಿಮ್ಮ ಮೂಲ ಮಾತ್ರ ಪ್ರತಿಗಳನ್ನು ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಲಾಗುತ್ತಿದೆ.

1250
01:17:41,540 --> 01:17:44,870
ನಾವು printf ಆಗಿ ಸ್ಟ್ರಿಂಗ್ ಹಾದುಹೋದಾಗ ಆದ್ದರಿಂದ, ನೀವು ಗಮನಿಸಿ

1251
01:17:44,870 --> 01:17:48,990
ನೀವು, ನಾವು ಎಲ್ಲಾ dereferences ಜೊತೆ ಮಾಡಿದರು ಹಾಗೆಯೇ ಮುಂದೆ ನಕ್ಷತ್ರ ಪುಟ್ ಹಕ್ಕನ್ನು ಹೊಂದಿಲ್ಲ?

1252
01:17:48,990 --> 01:17:54,180
ನೀವು ಸಂಪೂರ್ಣ ಸ್ಟ್ರಿಂಗ್% ರು ನಿರೀಕ್ಷಿಸುತ್ತದೆ ಮುದ್ರಿಸುತ್ತದೆ ಆದ್ದರಿಂದ, ಒಂದು ವಿಳಾಸ

1253
01:17:54,180 --> 01:17:57,610
ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಒಂದು ಪಾಯಿಂಟರ್ ಅಥವಾ ಪಾತ್ರಗಳು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರೀತಿ ಸಂದರ್ಭದಲ್ಲಿ.

1254
01:17:57,610 --> 01:18:00,330
>> ಪಾತ್ರಗಳು, ಚಾರ್ * ಗಳು, ಮತ್ತು ಸರಣಿಗಳ ಒಂದೇ ಆಗಿವೆ.

1255
01:18:00,330 --> 01:18:03,690
ಪಾಯಿಂಟರ್ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿದೆ, ಮತ್ತು ಪಾತ್ರದ ಸರಣಿಗಳನ್ನು ಒಂದೇ ಆಗಿವೆ.

1256
01:18:03,690 --> 01:18:05,720
ಆದ್ದರಿಂದ, ನಾವು ಎಲ್ಲಾ ಪಾಯಿಂಟರ್ ರಲ್ಲಿ ಅನುಮೋದನೆ ಇದೆ.

1257
01:18:05,720 --> 01:18:08,150
ನಾವು * ಪಾಯಿಂಟರ್ ಅಥವಾ ಹಾಗೆ ಏನು ನಂತಹ ರಲ್ಲಿ ಅನುಮೋದನೆ ಇಲ್ಲ.

1258
01:18:13,110 --> 01:18:14,930
ಆದ್ದರಿಂದ, ರಚನೆಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್ಸ್ ಒಂದೇ ಆಗಿವೆ.

1259
01:18:14,930 --> 01:18:19,160
ನೀವು X ರೀತಿಯ ಮಾಡುವುದರಿಂದ ನೀವು ಇಲ್ಲಿ ಮೇಲೆ ಒಂದು ಶ್ರೇಣಿಗಾಗಿ [ವೈ]

1260
01:18:19,160 --> 01:18:21,960
ಅದರ HOOD ಅಡಿಯಲ್ಲಿ ಮಾಡುತ್ತಿದ್ದಾರೆ ಹೇಳುವ ಎಂದರೆ, ಸರಿ, ಇದು, ಒಂದು ಪಾತ್ರವನ್ನು ವ್ಯೂಹವನ್ನು ಇಲ್ಲಿದೆ

1261
01:18:21,960 --> 01:18:23,690
ಆದ್ದರಿಂದ ಒಂದು ಪಾಯಿಂಟರ್ ಇಲ್ಲಿದೆ.

1262
01:18:23,690 --> 01:18:26,510
ಹೀಗಾಗಿ X, ಒಂದೇ ಆಗಿವೆ

1263
01:18:26,510 --> 01:18:28,650
ಮತ್ತು ಆದ್ದರಿಂದ ಏನು, ಇದು X ಗೆ ವೈ ಸೇರ್ಪಡೆಯಾಗುತ್ತದೆ

1264
01:18:28,650 --> 01:18:31,820
ಸಾಕಷ್ಟು ಮೆಮೊರಿ ಮುಂದೆ ಚಲಿಸುತ್ತಿರುವ ಅದೇ ವಿಷಯ ಇದು.

1265
01:18:31,820 --> 01:18:34,930
ಈಗ x + y, ನಮಗೆ ವಿಳಾಸಕ್ಕೆ ಕೆಲವು ರೀತಿಯ ನೀಡುತ್ತದೆ

1266
01:18:34,930 --> 01:18:37,570
ಮತ್ತು ನಾವು ವಿಳಾಸಕ್ಕೆ dereference ಅಥವಾ ಬಾಣದ ಅನುಸರಿಸಲು

1267
01:18:37,570 --> 01:18:41,640
ಅಲ್ಲಿ ಮೆಮೊರಿ ಆ ಸ್ಥಳ ಮತ್ತು ನಾವು ಮೆಮೊರಿ ಆ ಸ್ಥಳ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು.

1268
01:18:41,640 --> 01:18:43,720
ಆದ್ದರಿಂದ, ಆದ್ದರಿಂದ ಈ ಎರಡು ಒಂದೇ ಆಗಿವೆ.

1269
01:18:43,720 --> 01:18:45,840
ಇದು ಕೇವಲ ಒಂದು ವಾಕ್ಯರಚನೆಯ ಸಕ್ಕರೆಗಳನ್ನು.

1270
01:18:45,840 --> 01:18:48,090
ಅವರು ಒಂದೇ ವಿಷಯವನ್ನು. ಅವರು ಪರಸ್ಪರ ಕೇವಲ ವಿವಿಧ syntactics ಆರ್.

1271
01:18:51,500 --> 01:18:57,590
>> ಆದ್ದರಿಂದ, ಪಾಯಿಂಟರ್ಸ್ ಜೊತೆ ತಪ್ಪು ಏನು ಮಾಡಬಹುದು? ಬಹಳಷ್ಟು, ಹಾಗೆ. ಸರಿ. ಆದ್ದರಿಂದ, ಕೆಟ್ಟ ಸಂಗತಿಗಳು.

1272
01:18:57,590 --> 01:19:02,410
ನಿಮ್ಮ malloc ಕರೆ ಶೂನ್ಯ, ಬಲ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ನೀವು ಮಾಡಬಹುದು ಕೆಲವು ಕೆಟ್ಟ ವಿಷಯಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಇಲ್ಲ?

1273
01:19:02,410 --> 01:19:06,560
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ನೀಡಲು ವ್ಯವಸ್ಥೆ ಕೇಳುವ ನಾನು - ಆ ಸಂಖ್ಯೆ ಏನು?

1274
01:19:06,560 --> 01:19:11,200
ಒಂದು ಪೂರ್ಣಾಂಕ ಗಾತ್ರವನ್ನು 4 ಬೈಟ್ಗಳು ಏಕೆಂದರೆ, 2 ಬಿಲಿಯನ್ ಬಾರಿ 4 ಲೈಕ್.

1275
01:19:11,200 --> 01:19:13,810
ನಾನು 8 ಬಿಲಿಯನ್ ಬೈಟ್ಗಳು ರೀತಿಯಲ್ಲಿ ಅದನ್ನು ಕೇಳುವ ನುಡಿದರು.

1276
01:19:13,810 --> 01:19:17,270
ಖಂಡಿತವಾಗಿಯೂ ನನ್ನ ಕಂಪ್ಯೂಟರ್ ನನಗೆ ಸಾಕಷ್ಟು ಮೆಮೊರಿಯನ್ನು ಮರಳಿ ನೀಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಹೋಗುವ ಇಲ್ಲ.

1277
01:19:17,270 --> 01:19:20,960
ಈ ಶೂನ್ಯ ವೇಳೆ ಮತ್ತು ನಾವು ಅಲ್ಲಿರುವ dereference ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ ಆದ್ದರಿಂದ, ಪರಿಶೀಲಿಸಿ ಇಲ್ಲ -

1278
01:19:20,960 --> 01:19:24,270
ಇದು ಇನ್ನು ಅಲ್ಲಿ ಬಾಣದ ಅನುಸರಿಸಲು - ನಾವು ಮೆಮೊರಿ ಇಲ್ಲ.

1279
01:19:24,270 --> 01:19:27,150
ಈ ನಾವು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing ಕರೆಯುತ್ತಾರೆ.

1280
01:19:27,150 --> 01:19:29,710
ಮತ್ತು ಈ ಮೂಲಭೂತವಾಗಿ ನೀವು segfault ಕಾರಣವಾಗುತ್ತದೆ.

1281
01:19:29,710 --> 01:19:31,790
ನೀವು segfault ರೀತಿಗಳ ಒಂದಾಗಿದೆ.

1282
01:19:34,090 --> 01:19:38,090
ನೀವು ಇತರ ಕೆಟ್ಟ ವಸ್ತುಗಳು - ಚೆನ್ನಾಗಿ OH.

1283
01:19:38,090 --> 01:19:40,650
ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ dereferencing ಮಾಡಲಾಯಿತು. ಸರಿ.

1284
01:19:40,650 --> 01:19:45,160
ಇತರ ಕೆಟ್ಟ ವಸ್ತುಗಳು - ಅಲ್ಲದೆ, ನೀವು ಇಲ್ಲಿ ಒಂದು ಚೆಕ್ ಪುಟ್ ಹೊಂದಿಸುವುದು

1285
01:19:45,160 --> 01:19:46,980
ಆ ಪಾಯಿಂಟರ್ ಶೂನ್ಯ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ

1286
01:19:46,980 --> 01:19:51,000
ಆ malloc ಒಂದು ಶೂನ್ಯ ಪಾಯಿಂಟರ್ ಹಿಂದಿರುಗಿಸುತ್ತದೆ ಉಂಟಾದರೆ ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ಔಟ್ ನಿರ್ಗಮಿಸಲು.

1287
01:19:55,110 --> 01:19:59,850
Xkcd ಕಾಮಿಕ್ ಆ. ಜನರು ಈಗ ಅರ್ಥ. ರೀತಿಯ.

1288
01:20:06,120 --> 01:20:09,350
>> ಆದ್ದರಿಂದ, ಮೆಮೊರಿ. ಮತ್ತು ನಾನು ಈ ಮೇಲೆ ಹೋದರು.

1289
01:20:09,350 --> 01:20:12,000
ನಾವು ಒಂದು ಆವರ್ತನದಲ್ಲಿ malloc ಕರೆ, ಆದರೆ ನಾವು malloc ಕರೆ ಪ್ರತಿ ಬಾರಿ ನೀವು

1290
01:20:12,000 --> 01:20:14,370
ನಾವು, ಈ ಪಾಯಿಂಟರ್ ತೋರುತ್ತಿರುವಂತೆ ಅಲ್ಲಿ ಜಾಡು ಕಳೆದುಕೊಳ್ಳುತ್ತಿದ್ದೇವೆ

1291
01:20:14,370 --> 01:20:15,750
ನಾವು clobbering ಇರುವ ಕಾರಣ.

1292
01:20:15,750 --> 01:20:18,410
ಆದ್ದರಿಂದ, malloc ಆರಂಭಿಕ ಕರೆ ನನಗೆ ಇಲ್ಲಿ ಮೆಮೊರಿ ಮೇಲೆ ನೀಡುತ್ತದೆ.

1293
01:20:18,410 --> 01:20:19,990
ಈ ನನ್ನ ಪಾಯಿಂಟರ್ ಪಾಯಿಂಟರ್ಸ್.

1294
01:20:19,990 --> 01:20:23,020
ಈಗ, ನಾನು ಇದು ಉಚಿತ ಇಲ್ಲ, ಆದ್ದರಿಂದ ಈಗ ನಾನು ಮತ್ತೆ malloc ಕರೆ.

1295
01:20:23,020 --> 01:20:26,070
ಈಗ ಇಲ್ಲಿ ಸುಮಾರು ಸೂಚಿಸುತ್ತಿದೆ. ಈಗ ನನ್ನ ಮೆಮೊರಿ ಇಲ್ಲಿ ಮೇಲೆ ತೋರಿಸುವ ಇದೆ.

1296
01:20:26,070 --> 01:20:27,640
ಇಲ್ಲಿ ಮೇಲೆ ಸೂಚಿಸುವ. ಇಲ್ಲಿ ಮೇಲೆ ಸೂಚಿಸುವ.

1297
01:20:27,640 --> 01:20:31,820
ಆದರೆ ಇಲ್ಲಿ ನಾನು ವಿಂಗಡಿಸುವ ಎಲ್ಲಾ ಮೆಮೊರಿ ವಿಳಾಸಗಳ ಲಾಸ್ಟ್ ಟ್ರ್ಯಾಕ್ ಮಾಡಿದ.

1298
01:20:31,820 --> 01:20:35,100
ಆದ್ದರಿಂದ ಈಗ ನಾನು ಅವುಗಳನ್ನು ಇನ್ನು ಮುಂದೆ ಯಾವುದೇ ಉಲ್ಲೇಖ ಇಲ್ಲ.

1299
01:20:35,100 --> 01:20:37,230
ಆದ್ದರಿಂದ, ನಾನು ಈ ಕುಣಿಕೆಯಿಂದ ಹೊರಗೆ ಅವರನ್ನು ಮುಕ್ತಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.

1300
01:20:37,230 --> 01:20:39,390
ಆದ್ದರಿಂದ, ಈ ರೀತಿಯ ಪರಿಹಾರ ಹುಡುಕುವ ಸಲುವಾಗಿ

1301
01:20:39,390 --> 01:20:42,250
ನೀವು ಉಚಿತ ಮೆಮೊರಿ ಮರೆಯ ಮತ್ತು ಈ ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಪಡೆಯಲು ವೇಳೆ,

1302
01:20:42,250 --> 01:20:45,810
ನೀವು ಅದನ್ನು ಪೂರೈಸಿದ ಒಮ್ಮೆ ಈ ಲೂಪ್ ಒಳಗೆ ಮೆಮೊರಿ ಮುಕ್ತಗೊಳಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

1303
01:20:45,810 --> 01:20:51,400
ಅಲ್ಲದೆ, ಈ ಏನಾಗುತ್ತದೆ ಹೊಂದಿದೆ. ನಾನು ಸಾಕಷ್ಟು ಈ ದ್ವೇಷದ ತಿಳಿದಿದೆ.

1304
01:20:51,400 --> 01:20:55,270
ಆದರೆ ಈಗ - ವಾಹ್! ನೀವು 44,000 ಕಿಲೋಬೈಟ್ಗಳಷ್ಟು ನಂತಹ ಪಡೆಯಿರಿ.

1305
01:20:55,270 --> 01:20:57,110
ಆದ್ದರಿಂದ, ನೀವು, ಲೂಪ್ ಕೊನೆಯಲ್ಲಿ ಕ್ಲಿಕ್

1306
01:20:57,110 --> 01:20:59,770
ಮತ್ತು ಕೇವಲ ಮೆಮೊರಿ ಪ್ರತಿ ಬಾರಿ ಮುಕ್ತಗೊಳಿಸಲು ವಿಶೇಷವೇನು.

1307
01:20:59,770 --> 01:21:03,620
ಮೂಲಭೂತವಾಗಿ, ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಎಂದಿಗೂ ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿಲ್ಲ.

1308
01:21:03,620 --> 01:21:08,150
>> ಈಗ ನೀವು ಮಾಡಬಹುದು ಯಾವುದೋ ನೀವು ಎರಡು ಬಾರಿ ಕೇಳಿದರು ನೀವು ಕೆಲವು ಮೆಮೊರಿ ಉಚಿತ.

1309
01:21:08,150 --> 01:21:11,060
ಈ ಪ್ರಕರಣದಲ್ಲಿ, ನೀವು malloc ಏನಾದರೂ, ನೀವು ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಬಹುದು.

1310
01:21:11,060 --> 01:21:13,140
ನೀವು ಅದನ್ನು ಮಾಡಿದ ಹೇಳಿದರು ಒಮ್ಮೆ ನೀವು ಕ್ಲಿಕ್.

1311
01:21:13,140 --> 01:21:14,940
ಆದರೆ ನಂತರ ನಾವು ಮತ್ತೆ ಬಿಡುಗಡೆ.

1312
01:21:14,940 --> 01:21:16,730
ಇದು ತುಂಬಾ ಹಾನಿಕಾರಕ ವಿಷಯ.

1313
01:21:16,730 --> 01:21:18,820
ಇದು ಆರಂಭದಲ್ಲಿ segfault ಹಿಂದಿರುಗಬಹುದೆಂದು

1314
01:21:18,820 --> 01:21:23,350
ಆದರೆ ನಂತರ ಈ ಜೋಡಿ ಈ corrupts ನಿಮ್ಮ ರಾಶಿ ರಚನೆ ಮುಕ್ತಗೊಳಿಸಿದ ಇದೆ ಏನು ಆದರೆ,

1315
01:21:23,350 --> 01:21:27,200
ನೀವು CS61 ರೀತಿಯ ಒಂದು ವರ್ಗ ತೆಗೆದುಕೊಳ್ಳಲು ಆಯ್ಕೆ ವೇಳೆ ಮತ್ತು ಈ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ತಿಳಿಯುವಿರಿ.

1316
01:21:27,200 --> 01:21:30,000
ಆದರೆ ಮೂಲಭೂತವಾಗಿ ನಂತರ ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್ ತಪ್ಪಾಗಿ ಹೋಗುವ ಸಮಯ

1317
01:21:30,000 --> 01:21:33,010
- ಅಲ್ಲಿ ಮತ್ತು ಅಲ್ಲಿ ಅದು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಸ್ಮರಣೆಯ ಯಾವ ಸ್ಥಳಗಳು ಬಗ್ಗೆ

1318
01:21:33,010 --> 01:21:34,800
ಅಲ್ಲಿ ಅಕ್ಷಾಂಶ ಮೆಮೊರಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

1319
01:21:34,800 --> 01:21:38,080
ಮತ್ತು ಆದ್ದರಿಂದ ಒಂದು ಪಾಯಿಂಟರ್ ಮುಕ್ತಗೊಳಿಸಿದ ಬಾರಿ ನೀವು ಬಯಸದಿದ್ದರೆ ಒಂದು ಕೆಟ್ಟ ವಿಷಯ.

1320
01:21:38,080 --> 01:21:41,600
>> ತಪ್ಪು ಹೋಗಿ ಇತರ ವಿಷಯಗಳನ್ನು sizeof ಬಳಸದೇ.

1321
01:21:41,600 --> 01:21:44,460
ಆದ್ದರಿಂದ, ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು, 8 ಬೈಟ್ಗಳು malloc

1322
01:21:44,460 --> 01:21:46,700
ಮತ್ತು ಬಲ, ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಅದೇ ವಿಷಯ?

1323
01:21:46,700 --> 01:21:49,580
ಆದ್ದರಿಂದ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಸುರಕ್ಷಿತವಾಗಿರುತ್ತವೆ, ಆದರೆ ಹೊಂದಿದೆ?

1324
01:21:49,580 --> 01:21:52,160
ಅಲ್ಲದೆ, ಲ್ಯೂಕಾಸ್, ವಿವಿಧ ಆರ್ಕಿಟೆಕ್ಚರುಗಳ ಮೇಲೆ ಬಗ್ಗೆ ಮಾತನಾಡಿಸಿ

1325
01:21:52,160 --> 01:21:54,220
ಪೂರ್ಣಾಂಕಗಳ ವಿವಿಧ ಉದ್ದದ ಇವೆ.

1326
01:21:54,220 --> 01:21:57,970
ಆದ್ದರಿಂದ, ನೀವು ಬಳಸುವ ಆ ಉಪಕರಣದಲ್ಲಿ, ಪೂರ್ಣಾಂಕಗಳು ಸುಮಾರು 4 ಬೈಟ್ಗಳು, ಅವು

1327
01:21:57,970 --> 01:22:02,370
ಆದರೆ ಕೆಲವು ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಅವರು 8 ಬೈಟ್ಗಳು ಇರಬಹುದು ಅಥವಾ ಅವು 16 ಬೈಟ್ಗಳು ಇರಬಹುದು.

1328
01:22:02,370 --> 01:22:05,680
ಆದ್ದರಿಂದ, ನಾನು ಇಲ್ಲಿ ಈ ಸಂಖ್ಯೆ ಬಳಸುತ್ತಿದ್ದರೆ,

1329
01:22:05,680 --> 01:22:07,310
ಈ ಕಾರ್ಯಕ್ರಮವು, ಉಪಕರಣದಲ್ಲಿ ಕೆಲಸ

1330
01:22:07,310 --> 01:22:10,360
ಆದರೆ ಕೆಲವು ಇತರ ಗಣಕದಲ್ಲಿ ಸಾಕಷ್ಟು ಮೆಮೊರಿ ನಿಯೋಜಿಸಿ ಹಿಂದಿರುಗಬಹುದೆಂದು.

1331
01:22:10,360 --> 01:22:14,020
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ sizeof ಆಯೋಜಕರು ಬಳಸಲಾಗುತ್ತದೆ ಏನು.

1332
01:22:14,020 --> 01:22:16,880
ಏನು ಮಾಡುತ್ತದೆ ನಮಗೆ ಕರೆ ಮಾಡಿದಾಗ sizeof (ಇಂಟ್),

1333
01:22:16,880 --> 01:22:21,910
 ನಮಗೆ ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವ ಗಣಕದಲ್ಲಿ ಪೂರ್ಣಾಂಕ ಗಾತ್ರವನ್ನು ನೀಡುತ್ತದೆ.

1334
01:22:21,910 --> 01:22:25,490
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, sizeof (ಇಂಟ್), APPLIANCE ರೀತಿಯ ಮೇಲೆ 4 ಹಿಂತಿರುಗುವುದು

1335
01:22:25,490 --> 01:22:29,980
ಈಗ 8 ಇದು ಈ ವಿಲ್ 4 * 2,,

1336
01:22:29,980 --> 01:22:32,330
ಇದು ಕೇವಲ ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಅಗತ್ಯವಿರುವ ಜಾಗದ ಪ್ರಮಾಣವನ್ನು.

1337
01:22:32,330 --> 01:22:36,710
ಬೇರೆ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಒಂದು int 16 ಬೈಟ್ಗಳು ಅಥವಾ 8 ಬೈಟ್ಗಳು ನಂತಹ ವೇಳೆ,

1338
01:22:36,710 --> 01:22:39,380
ಇದು ಕೇವಲ ಪ್ರಮಾಣವನ್ನು ಶೇಖರಿಸಿಡಲು ಸಾಕಷ್ಟು ಬೈಟ್ಗಳು ಮರಳಲು ವಿಶೇಷವೇನು.

1339
01:22:41,830 --> 01:22:45,310
>> ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ.

1340
01:22:45,310 --> 01:22:48,340
ಆದ್ದರಿಂದ, ನೀವು ನೆನಪಿನಲ್ಲಿ ಒಂದು ಸುಡೊಕು ಬೋರ್ಡ್ ಶೇಖರಿಸಿಡಲು ಬಯಸಿದರೆ, ಹೇಗೆ ನಾವು ಏನು ಮಾಡಬಹುದು?

1341
01:22:48,340 --> 01:22:51,570
ನೀವು, ಮೊದಲನೆಯದಾಗಿ ಒಂದು ವೇರಿಯೇಬಲ್ ರೀತಿಯ ನಗರದ ಇರಬಹುದು

1342
01:22:51,570 --> 01:22:53,820
ಎರಡನೆಯ ವಿಷಯ ಒಂದು ವೇರಿಯೇಬಲ್, ಮೂರನೇ ವಿಷಯ ಒಂದು ವೇರಿಯೇಬಲ್,

1343
01:22:53,820 --> 01:22:56,420
ಕೆಟ್ಟ, ಬಲ - ನಾಲ್ಕನೇ ವಿಷಯ ಒಂದು ವೇರಿಯೇಬಲ್?

1344
01:22:56,420 --> 01:23:00,750
ಆದ್ದರಿಂದ, ನೀವು ಈ ಮೇಲೆ ಮಾಡಬಹುದು ಒಂದು ಸುಧಾರಣೆ ಒಂದು 9 X 9 ರಚನೆಯ ಮಾಡುವುದು.

1345
01:23:00,750 --> 01:23:04,480
ಆ ಉತ್ತಮ, ಆದರೆ ನೀವು ಸುಡೊಕು ಮಂಡಳಿಯ ಇತರ ವಿಷಯಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಬಯಸಿದ್ದರು ಹೀಗಾದರೆ

1346
01:23:04,480 --> 01:23:06,490
, ಮಂಡಳಿಯ ಸಮಸ್ಯೆ ಏನು ಇಷ್ಟ

1347
01:23:06,490 --> 01:23:11,740
ಅಥವಾ, ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ಸ್ಕೋರ್, ಅಥವಾ ಎಷ್ಟು ಬಾರಿ ನೀವು ಈ ಬೋರ್ಡ್ ಪರಿಹರಿಸಲು ತೆಗೆದುಕೊಂಡದ್ದಾಗಿದೆ?

1348
01:23:11,740 --> 01:23:14,970
ಅಲ್ಲದೆ, ನೀವು ಏನು ಮಾಡಬಹುದು ನೀವು struct ರಚಿಸಬಹುದು ಹೊಂದಿದೆ.

1349
01:23:14,970 --> 01:23:18,910
ಏನು ನಾನು ಮೂಲತಃ ಹೇಳುವ, ನಾನು ಇಲ್ಲಿ ಈ ರಚನೆಯನ್ನು ವಿವರಿಸುವುದು ನನಗೆ

1350
01:23:18,910 --> 01:23:23,230
ಮತ್ತು ನಾನು X 9 9 ಒಂದು ಬೋರ್ಡ್ ಒಳಗೊಂಡ ಸುಡೊಕು ಬೋರ್ಡ್ ವ್ಯಾಖ್ಯಾನಿಸುವುದು ನುಡಿದರು.

1351
01:23:23,230 --> 01:23:26,650
>> ಮತ್ತು ಇದು ಮಟ್ಟದ ಹೆಸರು ರೀತಿಯು ಹೊಂದಿರುತ್ತದೆ ಎಂಬುದನ್ನು.

1352
01:23:26,650 --> 01:23:30,730
ಇದು ನಾನು ಈಗ ನಾನು ಅಲ್ಲಿ ನಿರ್ದೇಶಾಂಕ ಇವು X ​​ಮತ್ತು Y ಹೊಂದಿದೆ.

1353
01:23:30,730 --> 01:23:35,980
ಇದು ಸಮಯ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ಕಳೆದರು, ಮತ್ತು ನಾನು ಇಲ್ಲಿಯವರೆಗೆ ಇನ್ಪುಟ್ ನೀವು ಚಲಿಸುತ್ತದೆ ಒಟ್ಟು ಹೊಂದಿದೆ.

1354
01:23:35,980 --> 01:23:40,010
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಒಂದು ಕಟ್ಟಡಕ್ಕೆ ಅಕ್ಷಾಂಶ ಒಂದು ಇಡೀ ಗುಂಪೇ ಗುಂಪಿನಲ್ಲೇ ಮಾಡಬಹುದು

1355
01:23:40,010 --> 01:23:42,790
ಬದಲಾಗಿ ವಿವಿಧ ಚರಾಂಕಗಳ ನಂತಹ ಸುಮಾರು ಹಾರುವ ರೀತಿಯಲ್ಲಿ ಅದನ್ನು ಹೊಂದುವ

1356
01:23:42,790 --> 01:23:44,540
ನಾನು ಟ್ರ್ಯಾಕ್ ಇರಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ.

1357
01:23:44,540 --> 01:23:49,720
ಮತ್ತು ಈ ಈ struct ಒಳಗೆ ವಿವಿಧ ವಿಷಯಗಳನ್ನು ಗುರುತಿಸಲಾಗುತ್ತಿದೆ ರೀತಿಯ ಕೇವಲ ಸಂತೋಷವನ್ನು ವಾಕ್ಯ ಹೊಂದಿರುವ ಅನುಮತಿಸುತ್ತದೆ.

1358
01:23:49,720 --> 01:23:53,430
ನಾನು board.board ರೀತಿಯಲ್ಲಿಯೇ, ಮತ್ತು ನಾನು ಮತ್ತೆ ಸುಡೊಕು ಬೋರ್ಡ್ ಪಡೆಯಿರಿ.

1359
01:23:53,430 --> 01:23:56,320
Board.level, ನಾನು ಎಷ್ಟು ಕಠಿಣ ಪಡೆಯಿರಿ.

1360
01:23:56,320 --> 01:24:00,540
Board.x ಮತ್ತು board.y ನಾನು ಮಂಡಲಿಯಲ್ಲಿ ಇರಬಹುದು ಅಲ್ಲಿ ನಿರ್ದೇಶಾಂಕ ನೀಡಿ.

1361
01:24:00,540 --> 01:24:04,730
ಮತ್ತು ಆದ್ದರಿಂದ ನಾವು struct ಕ್ಷೇತ್ರಗಳು ಕರೆಯುವ ಪ್ರವೇಶಿಸುವ ನುಡಿದರು.

1362
01:24:04,730 --> 01:24:08,840
ನಾನು ಹೊಂದಿರುವ ಒಂದು ರೀತಿಯ ಇದು sudokuBoard, ವರ್ಣಿಸಬಹುದು.

1363
01:24:08,840 --> 01:24:14,800
ಈಗ ನಾವು ನೀವು. ನಾನು ರೀತಿಯ sudokuBoard ಆಫ್ "ಮಂಡಳಿ" ಎಂಬ ಮಾರ್ಪಡಿಸಬಹುದಾದ ಹೊಂದಿರುತ್ತವೆ.

1364
01:24:14,800 --> 01:24:18,820
ಆದ್ದರಿಂದ ಈಗ ನಾನು ಇಲ್ಲಿ ಈ ರಚನೆ ರೂಪಿಸುವ ಎಲ್ಲಾ ಜಾಗ ಪ್ರವೇಶಿಸಬಹುದು.

1365
01:24:20,830 --> 01:24:22,450
>> ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಬಗ್ಗೆ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು? ಹೌದು?

1366
01:24:22,450 --> 01:24:25,890
ಇಂಟ್ X, Y ಫಾರ್ [ವಿದ್ಯಾರ್ಥಿ], ನೀವು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಎರಡೂ ಡಿಕ್ಲೇರ್ಡ್? >> [ಜೋಸೆಫ್] ಹುಂ.

1367
01:24:25,890 --> 01:24:27,400
[ವಿದ್ಯಾರ್ಥಿ] ಆದ್ದರಿಂದ, ನೀವು ಅವುಗಳನ್ನು ಎಲ್ಲಾ ಹಾಗೆ ಸಾಧ್ಯವಾಯಿತು?

1368
01:24:27,400 --> 01:24:31,200
X ನಲ್ಲಿನ ಲೈಕ್, ವೈ ಅಲ್ಪವಿರಾಮ ಪಟ್ಟು ಒಟ್ಟು?

1369
01:24:31,200 --> 01:24:34,460
[ಜೋಸೆಫ್] ಹೌದು, ನೀವು ಖಂಡಿತವಾಗಿ ನಾನು ಅದೇ ಸಾಲಿನಲ್ಲಿ x ಮತ್ತು y ಪುಟ್ ಕಾರಣ ಹಾಗೆ, ಆದರೆ -

1370
01:24:34,460 --> 01:24:36,330
ನಾವು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಇದನ್ನು ಏಕೆ ಮತ್ತು ಪ್ರಶ್ನೆ?

1371
01:24:36,330 --> 01:24:38,600
ಯಾಕೆ ನಾವು ಅದೇ ಸಾಲಿನಲ್ಲಿ ಈ ಎಲ್ಲಾ ಇರಿಸಬೇಡಿ

1372
01:24:38,600 --> 01:24:42,090
x ಮತ್ತು y ಒಂದಕ್ಕೊಂದು ಸಂಬಂಧಪಟ್ಟಿವೆ,

1373
01:24:42,090 --> 01:24:44,780
ಮತ್ತು ಇದು ಒಂದು ಅರ್ಥದಲ್ಲಿ, ಕೇವಲ ಶೈಲಿಯಲ್ಲಿ ಹೆಚ್ಚು ಸರಿಯಾಗಿದೆ

1374
01:24:44,780 --> 01:24:46,600
ಇದು ಒಂದೇ ಸಾಲಿನಲ್ಲಿ ಎರಡು ವಸ್ತುಗಳ ಗುಂಪಿನ ವಿಶೇಷವೇನು ಏಕೆಂದರೆ

1375
01:24:46,600 --> 01:24:49,340
ಆ ರೀತಿಯ ರೀತಿಯ ಒಂದೇ ಸಂಬಂಧಿಸಿದೆ.

1376
01:24:49,340 --> 01:24:51,440
ಮತ್ತು ನಾನು ಹೊರತುಪಡಿಸಿ ಈ ವಿಭಜನೆಯಾಯಿತು. ಇದು ಕೇವಲ ಒಂದು ಶೈಲಿ ವಿಷಯ.

1377
01:24:51,440 --> 01:24:53,720
ಇದು ಕಾರ್ಯತಃ ಯಾವುದೇ ವ್ಯತ್ಯಾಸವಿಲ್ಲ.

1378
01:24:58,150 --> 01:24:59,270
ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳು?

1379
01:25:03,030 --> 01:25:06,620
ನೀವು struct ಒಂದು Pokédex ರೂಪಿಸಬಹುದು.

1380
01:25:06,620 --> 01:25:11,720
ಒಂದು ಪೊಕ್ಮೊನ್ ಹೊಂದಿದೆ ಮತ್ತು ಒಂದು ಅಕ್ಷರದ, ಮಾಲೀಕರು, ಒಂದು ರೀತಿಯ ಹೊಂದಿದೆ.

1381
01:25:11,720 --> 01:25:16,990
ನೀವು ಪೊಕ್ಮೊನ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿದ್ದರೆ ಮತ್ತು ನಂತರ, ನೀವು ಬಲ, ಒಂದು Pokédex ಅಪ್ ಮಾಡಬಹುದು?

1382
01:25:16,990 --> 01:25:20,810
ಸರಿ, ತಂಪು. ಆದ್ದರಿಂದ, ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಮೇಲೆ ಪ್ರಶ್ನೆಗಳು. ಆ ಸ್ಟ್ರಕ್ಟ್ಸ್ಳ ಸಂಬಂಧಿಸಿವೆ.

1383
01:25:20,810 --> 01:25:25,270
>> ಅಂತಿಮವಾಗಿ, GDB. GDB ನೀವು ಏನು ಅವಕಾಶ ಇಲ್ಲ? ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ದೋಷ ಅನುಮತಿಸುತ್ತದೆ.

1384
01:25:25,270 --> 01:25:27,650
ನೀವು GDB ಬಳಸದೆ ಇದ್ದಲ್ಲಿ ಮತ್ತು, ನಾನು ಸಣ್ಣ ವೀಕ್ಷಿಸಲು ಶಿಫಾರಸು ಎಂದು

1385
01:25:27,650 --> 01:25:31,250
ಮತ್ತು ಕೇವಲ GDB ಯಾವುದು ಹೋಗುವಾಗ, ಹೇಗೆ ನೀವು, ನೀವು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ಇದು ಕೆಲಸ

1386
01:25:31,250 --> 01:25:32,900
ಮತ್ತು ಒಂದು ಪ್ರೋಗ್ರಾಂ ಅದನ್ನು ಪರೀಕ್ಷಿಸಲು.

1387
01:25:32,900 --> 01:25:37,400
ಮತ್ತು ಆದ್ದರಿಂದ GDB ನೀವು ಅನುಮತಿಸುತ್ತದೆ ಅದರ ವಿರಾಮ [ಗ್ರಹಿಸುವುದಕ್ಕಾಗದ] ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಅವಕಾಶ ಹೊಂದಿದೆ

1388
01:25:37,400 --> 01:25:38,920
ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಲೈನ್.

1389
01:25:38,920 --> 01:25:42,600
ಉದಾಹರಣೆಗೆ, ನಾನು, ನನ್ನ ಕಾರ್ಯಕ್ರಮದ ಲೈನ್ 3 ರೀತಿಯ ನಲ್ಲಿ ವಿರಾಮ ನಿರ್ವಹಣೆ ಬಯಸುವ

1390
01:25:42,600 --> 01:25:46,010
ಮತ್ತು ನಾನು ಲೈನ್ 3 ನಲ್ಲಿ ಆಮ್ ಐ ಇವೆ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

1391
01:25:46,010 --> 01:25:49,710
ಒಂದು ಸಾಲಿನಲ್ಲಿ pausing ಇಷ್ಟಪಟ್ಟಾಗ ನಾವು ಕರೆಯುವ

1392
01:25:49,710 --> 01:25:52,350
ಈ ಸಾಲನ್ನು ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಪುಟ್ಟಿಂಗ್ ಕರೆ ಇದೆ

1393
01:25:52,350 --> 01:25:55,920
ನಂತರ ನಾವು ಆ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಕ್ರಮದ ರಾಜ್ಯ ಅಸ್ಥಿರ ಮುದ್ರಿಸುತ್ತದೆ.

1394
01:25:55,920 --> 01:25:58,990
>> ನಾವು ನಂತರ ಕಾರ್ಯಕ್ರಮದ ಲೈನ್ ಮೂಲಕ ಲೈನ್ ಮೂಲಕ ಅಲ್ಲಿ ಹೆಜ್ಜೆ ಮಾಡಬಹುದು.

1395
01:25:58,990 --> 01:26:03,200
ನಂತರ ನಾವು ಸಮಯದಲ್ಲಿ ಸ್ಟಾಕ್ ರಾಜ್ಯದ ನೋಡಬಹುದು.

1396
01:26:03,200 --> 01:26:08,600
ಮತ್ತು ಆದ್ದರಿಂದ GDB, ಎಂಬುದನ್ನು ನಾವು ನಾವು ಸಿ ಫೈಲ್ನಲ್ಲಿ ಖಣಿಲು ಕಾಲ್ ಆಗಿದೆ, ಬಳಸಲು

1397
01:26:08,600 --> 01:26:11,290
ಆದರೆ ನಾವು ಅದನ್ನು ggdb ಧ್ವಜ ರವಾನಿಸಲು ಹೊಂದಿರುತ್ತವೆ.

1398
01:26:11,290 --> 01:26:15,850
ಮತ್ತು ಒಮ್ಮೆ ನಾವು ಫಲಿತಾ ಔಟ್ಪುಟ್ ಕಡತವನ್ನು ಮೇಲೆ GDB ಓಡುವ ಪೂರೈಸಿದ.

1399
01:26:15,850 --> 01:26:18,810
ಆದ್ದರಿಂದ ನೀವು ಈ ರೀತಿ ಪಠ್ಯದ ಕೆಲವು ರೀತಿಯ ಸಾಮೂಹಿಕ ಪಡೆಯಿರಿ

1400
01:26:18,810 --> 01:26:21,990
ಆದರೆ ನೀವು ಮಾಡಬೇಕು ನಿಜವಾಗಿಯೂ ಎಲ್ಲಾ ಆರಂಭದಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಟೈಪ್ ಇದೆ.

1401
01:26:21,990 --> 01:26:24,250
ಬ್ರೇಕ್ ಮುಖ್ಯ ಮುಖ್ಯ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಇರಿಸುತ್ತದೆ.

1402
01:26:24,250 --> 01:26:28,470
ಪಟ್ಟಿ 400 ಲೈನ್ 400 ಸುತ್ತ ಕೋಡ್ ಸಾಲುಗಳನ್ನು ಪಟ್ಟಿಮಾಡುತ್ತದೆ.

1403
01:26:28,470 --> 01:26:31,410
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು, ಓಹ್, ಹುಡುಕುತ್ತೇನೆ ಮತ್ತು ಹೇಳಬಹುದು

1404
01:26:31,410 --> 01:26:34,360
ಈ ಸಾಲಿನಲ್ಲಿ ಇದು 397 ಲೈನ್ ಒಂದು ಬ್ರೇಕ್ಪಾಯಿಂಟ್, ಸೆಟ್ ಬಯಸುವ

1405
01:26:34,360 --> 01:26:37,170
ತದನಂತರ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಆ ಹಂತದ ಹೋಗುತ್ತಾನೆ ಮತ್ತು ಅದನ್ನು ಮುರಿಯಲು ವಿಶೇಷವೇನು.

1406
01:26:37,170 --> 01:26:41,120
ಇದು ಅಲ್ಲಿ ತಾತ್ಕಾಲಿಕ ವಿಶೇಷವೇನು, ಮತ್ತು ನೀವು, ಉದಾಹರಣೆಗೆ, ಕಡಿಮೆ ಅಥವಾ ಹೆಚ್ಚಿನ ಮೌಲ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

1407
01:26:41,120 --> 01:26:46,410
ಆದ್ದರಿಂದ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಆಜ್ಞೆಗಳ ಒಂದು ಗುಂಪೇ ಇವೆ

1408
01:26:46,410 --> 01:26:48,660
ಮತ್ತು ಈ ಸ್ಲೈಡ್ಶೋ, ವೆಬ್ಸೈಟ್ ಮೇಲೆ ಹೋಗುತ್ತದೆ

1409
01:26:48,660 --> 01:26:54,000
ನೀವು ಈ ಉಲ್ಲೇಖಿಸಿ ನೀವು ಅಥವಾ ನಿಮ್ಮ ಮೋಸಮಾಡುವುದನ್ನು ಹಾಳೆಗಳ ಮೇಲೆ ಇರಿಸಿ ಇಷ್ಟ ಹಾಗಾಗಿ, ಹಿಂಜರಿಯಬೇಡಿ.

1410
01:26:54,000 --> 01:27:00,650
>> ಕೂಲ್. ಆ ರಸಪ್ರಶ್ನೆ ರಿವ್ಯೂ 0 ಆಗಿತ್ತು, ಮತ್ತು ನೀವು ಯಾವುದೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ನಾವು ಸುಮಾರು ಅಂಟಿಕೊಳ್ಳುವುದಿಲ್ಲ ಮಾಡುತ್ತೇವೆ.

1411
01:27:00,650 --> 01:27:03,850
ಎಲ್ಲಾ ಸರಿ.

1412
01:27:03,850 --> 01:27:09,030
>>  [ಚಪ್ಪಾಳೆಯನ್ನು]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]