1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] ನ ಸರಣಿಗಳ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

2
00:00:09,360 --> 00:00:12,780
ಆದ್ದರಿಂದ ನಾವು ಸರಣಿಗಳ ಬಳಸಲು ಬಯಸುತ್ತೇನೆ?

3
00:00:12,780 --> 00:00:17,210
ಹಾಗೂ ಈಗ ನೀವು 5 ವಿದ್ಯಾರ್ಥಿಗಳ ID ಸಂಗ್ರಹಿಸಲು ಅಗತ್ಯವಿರುವ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಹೇಳುತ್ತಾರೆ.

4
00:00:17,210 --> 00:00:21,270
ಇದು 5 ಪ್ರತ್ಯೇಕ ಅಸ್ಥಿರ ಹೊಂದಿರುವ ಸಮಂಜಸವಾದ ತೋರುತ್ತದೆ ಇರಬಹುದು.

5
00:00:21,270 --> 00:00:24,240
ನಾವು ಕೂಡಲೇ ನೋಡುತ್ತಾರೆ ಕಾರಣಗಳಿಗಾಗಿ, ನಾವು 0 ರಿಂದ ಎಣಿಕೆಮಾಡುವಿಕೆಯನ್ನಾದರೂ ಪ್ರಾರಂಭಿಸಿ.

6
00:00:24,240 --> 00:00:30,700
ನಾವು ನೀವು ಅಸ್ಥಿರ ಇಂಟ್ id0, ಇಂಟ್ id1, ಹೀಗೆ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

7
00:00:30,700 --> 00:00:34,870
ನಾವು ವಿದ್ಯಾರ್ಥಿ ID ಯನ್ನು ಮೇಲೆ ನಿರ್ವಹಿಸಲು ಬಯಸುವ ಯಾವುದೇ ಲಾಜಿಕ್ ನಕಲು ಮತ್ತು ಅಂಟಿಸಲು ಅಗತ್ಯವಿದೆ

8
00:00:34,870 --> 00:00:36,870
ಈ ವಿದ್ಯಾರ್ಥಿಗಳ ID ಪ್ರತಿ.

9
00:00:36,870 --> 00:00:39,710
ನಾವು, ವಿದ್ಯಾರ್ಥಿಗಳು CS50 ಎಂದು ಜರುಗುತ್ತದೆ ಪರಿಶೀಲಿಸಿ ಬಯಸಿದರೆ

10
00:00:39,710 --> 00:00:43,910
ನಾವು ಮೊದಲ id0 ಕೋರ್ಸಿಗೆ ವಿದ್ಯಾರ್ಥಿ ಪ್ರತಿನಿಧಿಸುತ್ತದೆ ವೇಳೆ ಪರಿಶೀಲಿಸಿ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

11
00:00:43,910 --> 00:00:48,070
ನಂತರ ಮುಂದಿನ ವಿದ್ಯಾರ್ಥಿ ಒಂದೇ ಮಾಡಲು, ನಾವು id0 ಕೋಡ್ ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ ಅಗತ್ಯವಿದೆ

12
00:00:48,070 --> 00:00:54,430
ಮತ್ತು id2, 3, ಮತ್ತು 4 id1 ಮತ್ತು ಹೀಗೆ id0 ಎಲ್ಲಾ ಘಟನೆಗಳು ಬದಲಾಯಿಸಿ.

13
00:00:54,430 --> 00:00:57,560
>> ತಕ್ಷಣ ನೀವು, ನಾವು ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ ಅಗತ್ಯವಿದೆ ಎಂಬುದನ್ನು ತಿಳಿದು ಮಾಹಿತಿ

14
00:00:57,560 --> 00:01:00,440
ನೀವು ಉತ್ತಮ ಪರಿಹಾರ ಎಂದು ತಿಳಿದು ಪ್ರಾರಂಭಿಸಬೇಕು.

15
00:01:00,440 --> 00:01:05,360
ಈಗ ನೀವು 5 ವಿದ್ಯಾರ್ಥಿಗಳ ID ಅಗತ್ಯವಿದೆ ಆದರೆ 7 ಇಲ್ಲ ಅರ್ಥ ವೇಳೆ?

16
00:01:05,360 --> 00:01:09,570
ನೀವು, ನಿಮ್ಮ ಮೂಲ ಕೋಡ್ ಮರಳಿ ಹೋಗಿ ಒಂದು id5 ರಲ್ಲಿ ಸೇರಿಸಲು id6, ಅಗತ್ಯವಿದೆ

17
00:01:09,570 --> 00:01:14,260
ಐಡಿಗಳನ್ನು ಈ 2 ಹೊಸ ಐಡಿಗಳಿಗೆ ವರ್ಗ ಸೇರಿರುವ ವೇಳೆ ಮತ್ತು ಪರಿಶೀಲನೆಗಾಗಿ ತರ್ಕ ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ.

18
00:01:14,260 --> 00:01:19,600
ಒಟ್ಟಿಗೆ ಎಲ್ಲಾ ID ಗಳನ್ನು ಸಂಪರ್ಕಿಸುವ ಏನೂ ಇಲ್ಲ, ಮತ್ತು ಆದ್ದರಿಂದ ಕೇಳುವ ದಾರಿಯೇ ಇಲ್ಲ

19
00:01:19,600 --> 00:01:22,040
ಪ್ರೋಗ್ರಾಂ 6 ಮೂಲಕ ಐಡಿಗಳನ್ನು 0 ಈ ಕೆಲಸವನ್ನು ಮಾಡಬೇಕು.

20
00:01:22,040 --> 00:01:26,120
ಬಾವಿಯನ್ನು ಈಗ ನೀವು 100 ವಿದ್ಯಾರ್ಥಿಗಳ ID ಹೊಂದಿರುತ್ತವೆ ಅರ್ಥ.

21
00:01:26,120 --> 00:01:30,770
ಇದು ಪ್ರತ್ಯೇಕವಾಗಿ ಈ ID ಗಳ ಪ್ರತಿ ಘೋಷಿಸಲು ಅಗತ್ಯ ಆದರ್ಶ ಕಡಿಮೆ ತೋರುತ್ತದೆ ಗೆ ಶುರುವಾಗುತ್ತಿದೆ

22
00:01:30,770 --> 00:01:33,760
ಮತ್ತು ಆ ಹೊಸ ಐಡಿಗಳನ್ನು ಯಾವುದೇ ಲಾಜಿಕ್ ನಕಲಿಸಿ ಮತ್ತು ಅಂಟಿಸಿ.

23
00:01:33,760 --> 00:01:38,380
ಆದರೆ ಬಹುಶಃ ತೀರ್ಮಾನಕ್ಕೆ ನಾವು, ಮತ್ತು ನಾವು ಎಲ್ಲಾ 100 ವಿದ್ಯಾರ್ಥಿಗಳಿಗೆ ಇದನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.

24
00:01:38,380 --> 00:01:42,240
ನೀವು ಗೊತ್ತಿಲ್ಲ ಆದರೆ ವಾಸ್ತವವಾಗಿ ಎಷ್ಟು ವಿದ್ಯಾರ್ಥಿಗಳು ಏನನ್ನು ಇವೆ?

25
00:01:42,240 --> 00:01:47,320
ಕೆಲವು N ವಿದ್ಯಾರ್ಥಿಗಳು ಕೇವಲ ಮತ್ತು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ N ಎಂದು ಯಾವ ಬಳಕೆದಾರ ಪಡೆಯಬೇಕಾಗುತ್ತದೆ.

26
00:01:47,320 --> 00:01:50,250
ಓಹ್. ಈ ಉತ್ತಮ ಕೆಲಸಕ್ಕೆ ಹೋಗುತ್ತಿಲ್ಲ ಇದೆ.

27
00:01:50,250 --> 00:01:53,820
ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಮಾತ್ರ ವಿದ್ಯಾರ್ಥಿಗಳು ಕೆಲವು ಸ್ಥಿರ ಸಂಖ್ಯೆ ಕೆಲಸ.

28
00:01:53,820 --> 00:01:57,520
>> ಈ ಸಮಸ್ಯೆಗಳನ್ನು ಎಲ್ಲಾ ಪರಿಹರಿಸುವ ಆಯ್ರೆಗಳ ಸೌಂದರ್ಯ ಹೊಂದಿದೆ.

29
00:01:57,520 --> 00:01:59,930
ಆದ್ದರಿಂದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಏನು?

30
00:01:59,930 --> 00:02:04,480
ಕೆಲವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಒಂದು ರಚನೆಯ ಪ್ರಕಾರ, ಒಂದು ಬಿಟ್ ಹೆಚ್ಚು ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ

31
00:02:04,480 --> 00:02:09,960
ನೀವು ಸಿ ಅದನ್ನು ನೋಡುತ್ತಾರೆ ಕೇವಲ ಇಲ್ಲಿ ನಾವು ಮೂಲ ರಚನೆಯ ಅಕ್ಷಾಂಶ ರಚನೆ ಗಮನ ಮಾಡುತ್ತೇವೆ

32
00:02:09,960 --> 00:02:14,030
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮೆಮೊರಿ ಕೇವಲ ದೊಡ್ಡ ಬ್ಲಾಕ್ ಆಗಿದೆ. ಅಷ್ಟೇ.

33
00:02:14,030 --> 00:02:17,770
ನಾವು ಕೇವಲ ನಾವು ಕೆಲವು ಬ್ಲಾಕ್ ಹೊಂದಿರುತ್ತವೆ ಎಂದರೆ, 10 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಸರಣಿ ಹೇಳುವುದಾದರೆ

34
00:02:17,770 --> 00:02:20,740
ಮೆಮೊರಿ 10 ಪ್ರತ್ಯೇಕ ಪೂರ್ಣಾಂಕಗಳು ಹಿಡಿದಿಡಲು ಸಾಕಷ್ಟು ದೊಡ್ಡದಾಗಿದೆ.

35
00:02:29,930 --> 00:02:33,410
ಒಂದು ಪೂರ್ಣಾಂಕ 4 ಬೈಟ್ಗಳು ಎಂದುಕೊಂಡರು, ಈ ಅರ್ಥ 10 ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು

36
00:02:33,410 --> 00:02:37,180
ನೆನಪಿಗಾಗಿ 40 ಬೈಟ್ಗಳು ನಿರಂತರ ಬ್ಲಾಕ್ ಆಗಿದೆ.

37
00:02:42,660 --> 00:02:46,280
ನಾವು ಇಲ್ಲಿ ಗೆ ಹೋಗಿ ಮಾಡುವುದಿಲ್ಲ ಇದು ಮಲ್ಟಿಡೈಮೆನ್ಷನಲ್ ಸಾಲುಗಳು, ಬಳಸಲು ಸಹ

38
00:02:46,280 --> 00:02:49,200
ಇದು ಇನ್ನೂ ಮೆಮೊರಿ ಕೇವಲ ದೊಡ್ಡ ಬ್ಲಾಕ್ ಇಲ್ಲಿದೆ.

39
00:02:49,200 --> 00:02:51,840
ಬಹುಆಯಾಮದ ಸಂಕೇತನ ಕೇವಲ ಒಂದು ಅನುಕೂಲ ಹೊಂದಿದೆ.

40
00:02:51,840 --> 00:02:55,640
ನೀವು ಪೂರ್ಣಾಂಕಗಳ 3 ಆಯಾಮದ ರಚನೆಯ ಒಂದು 3 ಹೊಂದಿದ್ದರೆ

41
00:02:55,640 --> 00:03:00,650
ನಂತರ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿಜವಾಗಿಯೂ ಕೇವಲ 36 ಬೈಟ್ಗಳು ದೊಡ್ಡ ಬ್ಲಾಕ್ ಎಂದು ಪರಿಗಣಿಸುತ್ತದೆ.

42
00:03:00,650 --> 00:03:05,460
ಪೂರ್ಣಾಂಕಗಳ ಒಟ್ಟು ಸಂಖ್ಯೆ 3 ಬಾರಿ 3, ಮತ್ತು ಪ್ರತಿ ಪೂರ್ಣಾಂಕ 4 ಬೈಟ್ಗಳು ಅಪ್ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

43
00:03:05,460 --> 00:03:07,750
>> ನ ಮೂಲಭೂತ ಉದಾಹರಣೆಯನ್ನು ಅವಲೋಕಿಸೋಣ.

44
00:03:07,750 --> 00:03:10,660
ನಾವು ಇಲ್ಲಿ ಘೋಷಿಸುವ ಆಯ್ರೆಗಳ 2 ರೀತಿಯಲ್ಲಿ ನೋಡಬಹುದು.

45
00:03:15,660 --> 00:03:18,580
ನಾವು ಸಂಕಲಿಸಲು ಕಾರ್ಯಕ್ರಮ ಅವುಗಳಲ್ಲಿ 1 ಔಟ್ ಕಾಮೆಂಟ್ ಮಾಡಬೇಕಾಗಬಹುದು

46
00:03:18,580 --> 00:03:20,900
ನಾವು ಎರಡು ಬಾರಿ X ಘೋಷಿಸಿದ ನಂತರ.

47
00:03:20,900 --> 00:03:25,140
ನಾವು ಕೂಡಲೇ ಘೋಷಣೆಗಳು ಈ 2 ವಿಧಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು ಕೆಲವು ನೋಡೋಣ ಮಾಡುತ್ತೇವೆ.

48
00:03:25,140 --> 00:03:28,560
ಈ ಸಾಲುಗಳನ್ನು ಎರಡೂ, ಗಾತ್ರ ಎನ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು

49
00:03:28,560 --> 00:03:30,740
ಅಲ್ಲಿ ನಾವು # 10 N ವ್ಯಾಖ್ಯಾನಿಸಲು ಮಾಡಿದ್ದಾರೆ.

50
00:03:30,740 --> 00:03:34,460
ನಾವು ಸುಲಭವಾಗಿ ಒಂದು ಪೂರ್ಣಸಂಖ್ಯೆ ಬಳಕೆದಾರ ಕೇಳಿದಾಗ ಇರಬಹುದು

51
00:03:34,460 --> 00:03:37,250
ಮತ್ತು ನಮ್ಮ ಶ್ರೇಣಿಯಲ್ಲಿನ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಆ ಪೂರ್ಣಾಂಕ ಬಳಸಲಾಗುತ್ತದೆ.

52
00:03:37,250 --> 00:03:41,960
ಮೊದಲು ನಮ್ಮ ವಿದ್ಯಾರ್ಥಿ ID ಯನ್ನು ಉದಾಹರಣೆಗೆ, ಈ ಸಂಪೂರ್ಣವಾಗಿ ಪ್ರತ್ಯೇಕ 10 ಘೋಷಿಸುವ ಹಾಗೆ ರೀತಿಯ ಹೊಂದಿದೆ

53
00:03:41,960 --> 00:03:49,000
ಕಾಲ್ಪನಿಕ ಅಸ್ಥಿರ; x0, x1, x2, ಮತ್ತು ಆದ್ದರಿಂದ xN-1 ವರೆಗಿನ ಮೇಲೆ.

54
00:03:57,270 --> 00:04:00,840
ನಾವು ಸರಣಿ ಘೋಷಿಸಲು ಅಲ್ಲಿ ರೇಖೆಗಳನ್ನು ಅವಗಣಿಸಿ, ಚದರ ಆವರಣಗಳಲ್ಲಿ ಹಾಗೆಯೇ ಗಮನಕ್ಕೆ

55
00:04:00,840 --> 00:04:02,090
ಕುಣಿಕೆಗಳು ಫಾರ್ ಒಳಗೆ.

56
00:04:02,090 --> 00:04:09,660
ನಾವು X ರೀತಿಯ ಬರೆಯಲು ಯಾವಾಗ [3], ಇದು ನಾನು, X ಬ್ರಾಕೆಟ್ 3 ಎಂದು ವಿಲ್

57
00:04:09,660 --> 00:04:13,090
ನೀವು ಕಾಲ್ಪನಿಕ X3 ಕೇಳುತ್ತಿದೆ ಎಂದು ನಗರದ.

58
00:04:13,090 --> 00:04:17,519
ಆ ಆವರಣಗಳಲ್ಲಿ ಒಳಗೆ ಸಂಖ್ಯೆ, ಗಾತ್ರ ಎನ್, ಇದರರ್ಥ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಭಿನ್ನವಾಗಿ ಗಮನಿಸಿ

59
00:04:17,519 --> 00:04:22,630
ನಾವು ಸೂಚ್ಯಂಕ ಕರೆ ಮಾಡುತ್ತೇವೆ ಇದು,, 0 ಯಿಂದ ಎನ್ 1 ಗೆ ಏನು ಮಾಡಬಹುದು

60
00:04:22,630 --> 00:04:25,660
ಇದು ಎನ್ ಸೂಚ್ಯಂಕಗಳು ಒಟ್ಟು ಹೊಂದಿದೆ.

61
00:04:25,660 --> 00:04:28,260
>> ಈ ವಾಸ್ತವವಾಗಿ ಕೆಲಸ ಹೇಗೆ ಎಂದು ಯೋಚಿಸಲು

62
00:04:28,260 --> 00:04:31,260
ಅರೇ ಮೆಮೊರಿ ದೊಡ್ಡ ಬ್ಲಾಕ್ ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ.

63
00:04:31,260 --> 00:04:37,460
ಒಂದು ಪೂರ್ಣಾಂಕ 4 ಬೈಟ್ಗಳು ಎಂದುಕೊಂಡರು, ಸಂಪೂರ್ಣ ರಚನೆಯ X ಮೆಮೊರಿ ಒಂದು 40 ಬೈಟ್ ಬ್ಲಾಕ್ ಆಗಿದೆ.

64
00:04:37,460 --> 00:04:41,360
ಆದ್ದರಿಂದ X0 ಬ್ಲಾಕ್ ಮೊದಲ 4 ಬೈಟ್ಗಳು ಸೂಚಿಸುತ್ತದೆ.

65
00:04:45,810 --> 00:04:49,230
ಎಕ್ಸ್ [1] ಮುಂದಿನ 4 ಬೈಟ್ಗಳು ಹೀಗೆ ಉಲ್ಲೇಖಿಸುತ್ತದೆ.

66
00:04:49,230 --> 00:04:53,760
ಈ X ಆರಂಭದಲ್ಲಿ ಹಿಂದೆಂದೂ ಕಾಪಾಡುವುದು ಅಗತ್ಯವಿದೆ ಎಲ್ಲಾ ಪ್ರೋಗ್ರಾಂ ಎಂದರ್ಥ.

67
00:04:55,660 --> 00:04:59,840
ನೀವು X [400] ಬಳಸಲು ಬಯಸಿದರೆ, ನಂತರ ಪ್ರೋಗ್ರಾಂ ಈ ಸಮಾನ ತಿಳಿದಿದೆ

68
00:04:59,840 --> 00:05:03,460
X ಪ್ರಾರಂಭವಾದ ನಂತರ ಕೇವಲ 1,600 ಬೈಟ್ಗಳು ಗೆ.

69
00:05:03,460 --> 00:05:08,780
ನಾವು 1,600 ಬೈಟ್ಗಳು ಪಡೆಯಲು Where'd? ಇದು ಪೂರ್ಣಾಂಕ ಪ್ರತಿ ಕೇವಲ 400 ಬಾರಿ 4 ಬೈಟ್ಗಳು ಇಲ್ಲಿದೆ.

70
00:05:08,780 --> 00:05:13,170
>> ಸ್ಥಳಾಂತರಗೊಳ್ಳುವ ಮೊದಲು, ಅದನ್ನು ಸಾಧಿಸುವುದಕ್ಕಾಗಿ ತುಂಬಾ ಮುಖ್ಯ ಎಂದು ಸಿ

71
00:05:13,170 --> 00:05:17,080
ನಾವು ಶ್ರೇಣಿಯಲ್ಲಿನ ಬಳಸುವ ಸೂಚಿಯ ಯಾವುದೇ ಜಾರಿ ಇಲ್ಲ.

72
00:05:17,080 --> 00:05:23,180
ನಮ್ಮ ದೊಡ್ಡ ಬ್ಲಾಕ್ ಕೇವಲ 10 ಪೂರ್ಣಾಂಕಗಳ ಉದ್ದವಾಗಿದೆ, ಆದರೆ ನಾವು X [20] ಬರೆಯಲು ವೇಳೆ ಏನನ್ನೂ ನಮಗೆ ನಲ್ಲಿ ಕೂಗಿ ಕಾಣಿಸುತ್ತದೆ

73
00:05:23,180 --> 00:05:26,060
ಅಥವಾ X [-5].

74
00:05:26,060 --> 00:05:28,240
ಸೂಚ್ಯಂಕ ಕೂಡ ಹಲವಾರು ಎಂದು ಹೊಂದಿಲ್ಲ.

75
00:05:28,240 --> 00:05:30,630
ಯಾವುದೇ ಕ್ರಮವಿಲ್ಲದ ಅಭಿವ್ಯಕ್ತಿ ಮಾಡಬಹುದು.

76
00:05:30,630 --> 00:05:34,800
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಾವು ರಚನೆಯ ಒಳಗೆ ಸೂಚ್ಯಂಕದ ಲೂಪ್ ಫಾರ್ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ನಾನು ಬಳಸಿ.

77
00:05:34,800 --> 00:05:40,340
ಈ, ನಾನು = 0 ಯಿಂದ ಶ್ರೇಣಿಯನ್ನು ಉದ್ದಕ್ಕೆ ಲೂಪಿಂಗ್, ಒಂದು ಸಾಮಾನ್ಯ ಮಾದರಿ

78
00:05:40,340 --> 00:05:43,350
ತದನಂತರ ಶ್ರೇಣಿಗೆ ಸೂಚ್ಯಂಕ ಎಂದು ನಾನು ಬಳಸಿ.

79
00:05:43,350 --> 00:05:46,160
ಸಂಪೂರ್ಣ ರಚನೆಯ ಮೇಲೆ ನೀವು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಲೂಪ್ ಈ ರೀತಿಯಲ್ಲಿ,

80
00:05:46,160 --> 00:05:50,600
ನೀವು ಅದರ ರಚನೆಯ ಪ್ರತಿ ಸ್ಥಾನಕ್ಕೆ ನಿಯೋಜಿಸಲು ಅಥವಾ ಕೆಲವು ಲೆಕ್ಕ ಬಳಸಬಹುದು.

81
00:05:50,600 --> 00:05:53,920
>> ಲೂಪ್ ಮೊದಲ ರಲ್ಲಿ, ನಾನು, 0 ಆರಂಭಗೊಂಡು

82
00:05:53,920 --> 00:05:58,680
ಮತ್ತು ಆದ್ದರಿಂದ ಶ್ರೇಣಿಯಲ್ಲಿನ 0 ಸ್ಥಾನ, ಮೌಲ್ಯವು 0 ಬಾರಿ 2 ನಿಗದಿ ಕಾಣಿಸುತ್ತದೆ.

83
00:05:58,680 --> 00:06:04,370
ನಂತರ ನಾನು ಬೆಳವಣಿಗೆಗಳ, ಮತ್ತು ನಾವು ಮೌಲ್ಯ 1 ಬಾರಿ 2 ರಚನೆಯ ಮೊದಲ ಸ್ಥಾನ ನಿಗದಿಪಡಿಸಬಹುದು.

84
00:06:04,370 --> 00:06:10,170
ನಂತರ ನಾವು ಶ್ರೇಣಿಯಲ್ಲಿನ N-1 ಸ್ಥಾನಗಳನ್ನು ಆಕ್ರಮಿಸಿಕೊಳ್ಳಲು ಅಪ್ ಮೇಲೆ ಮತ್ತೆ ನಾನು ಬೆಳವಣಿಗೆಗಳ ನಿಯೋಜಿಸಲು ರವರೆಗೆ

85
00:06:10,170 --> 00:06:13,370
ಮೌಲ್ಯ N-1 ಬಾರಿ 2.

86
00:06:13,370 --> 00:06:17,810
ನಾವು ಮೊದಲ 10 ಸಮ ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿರುವ ವ್ಯೂಹ ರಚಿಸಿದ.

87
00:06:17,810 --> 00:06:21,970
ಬಹುಶಃ evens X ಗಿಂತ ವೇರಿಯಬಲ್ ಒಂದು ಬಿಟ್ ಉತ್ತಮ ಹೆಸರನ್ನು ಹೇಳಲಾಗುತ್ತದೆ,

88
00:06:21,970 --> 00:06:24,760
ಆದರೆ ದೂರ ವಸ್ತುಗಳ ಸಿಕ್ಕಂತಾಗುತ್ತಿತ್ತು.

89
00:06:24,760 --> 00:06:30,210
ಲೂಪ್ ಎರಡನೆಯ ನಂತರ ನಾವು ಈಗಾಗಲೇ ರಚನೆಯ ಒಳಗೆ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಎಂದು ಮೌಲ್ಯಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.

90
00:06:30,210 --> 00:06:33,600
>> ಸರಣಿ ಹೇಳಿಕೆಗಳನ್ನು ಎರಡೂ ರೀತಿಯ ಕಾರ್ಯಕ್ರಮವನ್ನು ನಡೆಸುವ ಪ್ರಯತ್ನಿಸಿ ಲೆಟ್ಸ್

91
00:06:33,600 --> 00:06:36,330
ಮತ್ತು ಕಾರ್ಯಕ್ರಮದ ಔಟ್ಪುಟ್ ನೋಡೋಣ.

92
00:06:51,450 --> 00:06:57,020
ದೂರದ ನಾವು ನೋಡಬಹುದು ಎಂದು, ಪ್ರೋಗ್ರಾಂ ಘೋಷಣೆಗಳು ಎರಡೂ ವಿಧಗಳು ಒಂದೇ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುತ್ತದೆ.

93
00:06:57,020 --> 00:07:02,230
ನಾವು ಎನ್ ನಲ್ಲಿ ನಿಲ್ಲುವುದಿಲ್ಲ ಮೊದಲ ಲೂಪ್ ಬದಲಿಸಿದರೆ ಕೂಡ ಏನಾಗುತ್ತದೆ ಒಂದು ಗಮನಿಸೋಣ

94
00:07:02,230 --> 00:07:05,040
ಆದರೆ 10,000 ಹೇಳುತ್ತಾರೆ.

95
00:07:05,040 --> 00:07:07,430
ರಚನೆಯ ಕೊನೆಯ ಆಚೆಗೆ ವೇ.

96
00:07:14,700 --> 00:07:17,210
ಓಹ್. ಬಹುಶಃ ನೀವು ಮೊದಲು ಈ ನೋಡಿದ್ದೇವೆ.

97
00:07:17,210 --> 00:07:20,440
ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕ್ರ್ಯಾಶ್ ಆಗಿದೆ ಎಂದರ್ಥ.

98
00:07:20,440 --> 00:07:24,430
ನೀವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಮೆಮೊರಿಯ ಪ್ರದೇಶಗಳಲ್ಲಿ ಸ್ಪರ್ಶಿಸಿದಾಗ ನೀವು ಈ ಗಮನಕ್ಕೆ.

99
00:07:24,430 --> 00:07:27,870
ಇಲ್ಲಿ ನಾವು, X ಆರಂಭದಲ್ಲಿ ಮೀರಿ 10,000 ಸ್ಥಳಗಳಲ್ಲಿ ಸ್ಪರ್ಶಿಸುವ ಮಾಡಲಾಗುತ್ತದೆ

100
00:07:27,870 --> 00:07:31,920
ಇದು ಸ್ಪಷ್ಟವಾಗಿ ನಾವು ಸ್ಪರ್ಶಿಸುವ ಮಾಡಬಾರದು ಮೆಮೊರಿ ಒಂದು ಸ್ಥಳವಾಗಿದೆ.

101
00:07:31,920 --> 00:07:37,690
ನಮಗೆ ಅತ್ಯಂತ ಆದ್ದರಿಂದ ಬಹುಶಃ ಆಕಸ್ಮಿಕವಾಗಿ, ಬದಲಿಗೆ ಎನ್ 10,000 ಪುಟ್ ಎಂದು

102
00:07:37,690 --> 00:07:42,930
ನಾವು ಹೆಚ್ಚು ಸೂಕ್ಷ್ಮ ಏನಾದರೂ ಆದರೆ ಬರಹ ಕಡಿಮೆ ಅಥವಾ ಎನ್ ಸಮಾನವಾಗಿರುತ್ತದೆ ಏನು ಹೇಳುತ್ತಾರೆ

103
00:07:42,930 --> 00:07:46,830
ವಿರುದ್ಧವಾಗಿ ಫಾರ್ ಲೂಪ್ ಸ್ಥಿತಿಯಲ್ಲಿ ಎನ್ ಕಡಿಮೆ

104
00:07:46,830 --> 00:07:50,100
ಒಂದು ವ್ಯೂಹವನ್ನು ಮಾತ್ರ 0 ನಿಂದ N-1 ಸೂಚ್ಯಂಕಗಳು ಎಂದು ನೆನಪಿಡಿ,

105
00:07:50,100 --> 00:07:54,510
ಇದು ಸೂಚ್ಯಂಕ ಎನ್ ರಚನೆಯ ಕೊನೆಯ ಆಚೆಗೆ ಎಂದರ್ಥ.

106
00:07:54,510 --> 00:07:58,050
ಕಾರ್ಯಕ್ರಮವನ್ನು ಈ ಸಂದರ್ಭದಲ್ಲಿ ಕುಸಿತಕ್ಕೆ ಇರಬಹುದು, ಆದರೆ ಇದು ಇನ್ನೂ ಒಂದು ದೋಷವಾಗಿದೆ.

107
00:07:58,050 --> 00:08:01,950
ವಾಸ್ತವವಾಗಿ, ಈ ದೋಷ, ಅದು ಆದ ಹೆಸರನ್ನು ಹೊಂದಿರುವ ಆದ್ದರಿಂದ ಸಾಮಾನ್ಯ

108
00:08:01,950 --> 00:08:03,970
1 ದೋಷದ ಒಂದು ಆಫ್.

109
00:08:03,970 --> 00:08:05,970
>> ಬೇಸಿಕ್ಸ್ ಅದನ್ನು ಆ.

110
00:08:05,970 --> 00:08:09,960
ಆದ್ದರಿಂದ ರಚನೆಯ ಘೋಷಣೆಗಳು 2 ವಿಧಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು ಯಾವುವು?

111
00:08:09,960 --> 00:08:13,960
ಮೆಮೊರಿ ದೊಡ್ಡ ಬ್ಲಾಕ್ ಹೋಗುತ್ತದೆ ಅಲ್ಲಿ ಒಂದು ವ್ಯತ್ಯಾಸ.

112
00:08:13,960 --> 00:08:17,660
ಮೊದಲ ಘೋಷಣೆಯಲ್ಲಿ, ನಾನು, ಬ್ರಾಕೆಟ್-ರಚನೆಯ ಪ್ರಕಾರ ಇದು ಕರೆ ಮಾಡುತ್ತೇವೆ

113
00:08:17,660 --> 00:08:20,300
ಈ ಮೂಲಕ ಯಾವುದೇ, ಒಂದು ಸಾಂಪ್ರದಾಯಿಕ ಹೆಸರಿನ ಅರ್ಥ

114
00:08:20,300 --> 00:08:22,480
ಇದು ಸ್ಟಾಕ್ ಇರುತ್ತದೆ.

115
00:08:22,480 --> 00:08:27,450
ನಾನು ಪಾಯಿಂಟರ್-ಸರಣಿ ರೀತಿಯ ಕರೆ ಮಾಡುತ್ತೇವೆ ಇದು ಎರಡನೇ, ಆದರೆ, ಅದನ್ನು ರಾಶಿ ಇರುತ್ತದೆ.

116
00:08:27,450 --> 00:08:32,480
ಇದು ಯಾವಾಗ ಕಾರ್ಯವನ್ನು ಮರಳುತ್ತದೆ, ಬ್ರಾಕೆಟ್ ರಚನೆಯ ಸ್ವಯಂಚಾಲಿತವಾಗಿ deallocated ಎಂದು ಅರ್ಥ

117
00:08:32,480 --> 00:08:36,419
ನೀವು explicitily ಪಾಯಿಂಟರ್ ರಚನೆಯ ಉಚಿತ ಕರೆ ಮಾಡಬೇಕು ಎಂದು ಆದರೆ

118
00:08:36,419 --> 00:08:38,010
ಅಥವಾ ನೀವು ಒಂದು ಮೆಮೊರಿ ಸೋರಿಕೆಯಾದಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ.

119
00:08:38,010 --> 00:08:42,750
ಹೆಚ್ಚುವರಿಯಾಗಿ, ಬ್ರಾಕೆಟ್ ಶ್ರೇಣಿಯನ್ನು ವಾಸ್ತವವಾಗಿ ಒಂದು ವೇರಿಯೇಬಲ್ ಆಗಿಲ್ಲ.

120
00:08:42,750 --> 00:08:45,490
ಇದು ತುಂಬಾ ಮುಖ್ಯ. ಇದು ಕೇವಲ ಒಂದು ಸಂಕೇತ ಇಲ್ಲಿದೆ.

121
00:08:45,490 --> 00:08:49,160
ನೀವು ಕಂಪೈಲರ್ ನೀವು ಆಯ್ಕೆ ಒಂದು ಸ್ಥಿರ ಎಂದು ನಗರದ.

122
00:08:49,160 --> 00:08:52,970
ಇದು ನಾವು X + + ಬ್ರಾಕೆಟ್ ರೀತಿಯ ಹಾಗೆ ಏನನ್ನಾದರೂ ಮಾಡುವಂತಿಲ್ಲ

123
00:08:52,970 --> 00:08:56,240
ಈ ದುವಿನ ಪ್ರಕಾರದ ನಿಖರವಾಗಿ ಮಾನ್ಯ ಆದರೂ.

124
00:08:56,240 --> 00:08:58,270
>> ದುವಿನ ಪ್ರಕಾರದ ಒಂದು ಅಸ್ಥಿರವಾಗಿದೆ.

125
00:08:58,270 --> 00:09:01,510
ಪಾಯಿಂಟರ್ ರೀತಿಯ, ನಾವು ಮೆಮೊರಿ 2 ಪ್ರತ್ಯೇಕ ಬ್ಲಾಕ್ಗಳನ್ನು ಹೊಂದಿವೆ.

126
00:09:01,510 --> 00:09:06,060
ವ್ಯತ್ಯಯ X ಸ್ವತಃ ಸ್ಟಾಕ್ ಸಂಗ್ರಹವಾಗಿರುವ ಮತ್ತು ಕೇವಲ ಒಂದೇ ಸೂಚಿಯಾಗಿದೆ ಇದೆ

127
00:09:06,060 --> 00:09:08,620
ಆದರೆ ಮೆಮೊರಿಯ ದೊಡ್ಡ ಬ್ಲಾಕ್ ರಾಶಿ ಸಂಗ್ರಹಿಸಿದುದರಿಂದ.

128
00:09:08,620 --> 00:09:11,010
ಸ್ಟಾಕ್ ಮೇಲೆ ವ್ಯತ್ಯಯ X ಕೇವಲ ವಿಳಾಸವನ್ನು ಶೇಖರಿಸುತ್ತದೆ

129
00:09:11,010 --> 00:09:14,010
ರಾಶಿ ಮೆಮೊರಿಯ ದೊಡ್ಡ ಬ್ಲಾಕ್ನ.

130
00:09:14,010 --> 00:09:17,370
ಈ ಒಂದು ಸೂಚನೆಯ ಆಯೋಜಕರು ಗಾತ್ರಕ್ಕೆ ಹೊಂದಿದೆ.

131
00:09:17,370 --> 00:09:22,480
ನೀವು ಬ್ರಾಕೆಟ್ ರಚನೆಯ ಗಾತ್ರ ಕೇಳಲು, ಅದು, ನೀವು ಮೆಮೊರಿ ದೊಡ್ಡ ಬ್ಲಾಕ್ನ ಗಾತ್ರ ನೀಡುತ್ತದೆ

132
00:09:22,480 --> 00:09:24,620
40 ಬೈಟ್ಗಳು ನಂತೆ,

133
00:09:24,620 --> 00:09:26,920
ಆದರೆ ನೀವು ರಚನೆಯ ದುವಿನ ಪ್ರಕಾರದ ಗಾತ್ರಕ್ಕೆ ಕೇಳಲು ವೇಳೆ,

134
00:09:26,920 --> 00:09:32,740
ನೀವು ಉಪಕರಣದಲ್ಲಿ ಕೇವಲ 4 ಬೈಟ್ಗಳು ಸಂಭವವಿದೆ ವ್ಯತ್ಯಯ X ಸ್ವತಃ ಗಾತ್ರವನ್ನು ನೀಡುತ್ತದೆ.

135
00:09:32,740 --> 00:09:36,530
ಪಾಯಿಂಟರ್-ಸರಣಿ ರೀತಿಯ ಬಳಸಿ, ನೇರವಾಗಿ ಕೇಳುವುದಿಲ್ಲ ಅಸಾಧ್ಯ

136
00:09:36,530 --> 00:09:38,530
ಮೆಮೊರಿ ದೊಡ್ಡ ಬ್ಲಾಕ್ನ ಗಾತ್ರ.

137
00:09:38,530 --> 00:09:42,530
ನಾವು ಬಹಳ ಅಪರೂಪವಾಗಿ ಗಾತ್ರ ಬಯಸುವ ಏಕೆಂದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ನಿರ್ಬಂಧದ ಅಲ್ಲ

138
00:09:42,530 --> 00:09:46,980
ದೊಡ್ಡ ಮೆಮೊರಿ ಬ್ಲಾಕ್, ಮತ್ತು ನಾವು ಅಗತ್ಯವಿದ್ದರೆ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು.

139
00:09:46,980 --> 00:09:51,490
>> ಅಂತಿಮವಾಗಿ, ಬ್ರಾಕೆಟ್ ರಚನೆಯ ಒಂದು ವ್ಯೂಹವನ್ನು ಆರಂಭಿಸುವಲ್ಲಿ ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಒದಗಿಸಲು ಸಂಭವಿಸುತ್ತದೆ.

140
00:09:51,490 --> 00:09:56,130
ನಾವು ಶಾರ್ಟ್ಕಟ್ initilization ಬಳಸಿಕೊಂಡು ಮೊದಲ 10 ಕೂಡ ಪೂರ್ಣಾಂಕಗಳು ಬರೆಯಲು ಹೇಗೆ ನೋಡೋಣ.

141
00:10:11,220 --> 00:10:14,470
ಪಾಯಿಂಟರ್ ಸಹಿತ, ಈ ರೀತಿಯ ಒಂದು ಶಾರ್ಟ್ಕಟ್ ಮಾಡಲು ದಾರಿ ಇಲ್ಲ.

142
00:10:14,470 --> 00:10:18,120
ಇದು ಕೇವಲ ನೀವು ವ್ಯೂಹಗಳನ್ನು ಹೊಂದಿರುವ ಏನು ಮಾಡಬಹುದು ಒಂದು ಪರಿಚಯವಾಗಿದೆ.

143
00:10:18,120 --> 00:10:20,990
ಅವರು ನೀವು ಬರೆಯಲು ಪ್ರತಿಯೊಂದು ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ತೋರಿಸುತ್ತವೆ.

144
00:10:20,990 --> 00:10:24,390
ಆಶಾದಾಯಕವಾಗಿ ನೀವು ಈಗ ವಿದ್ಯಾರ್ಥಿಗಳ ID ಉದಾಹರಣೆಗೆ ಮಾಡುವ ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ನೋಡಬಹುದು

145
00:10:24,390 --> 00:10:26,710
ವೀಡಿಯೊ ಆರಂಭದಲ್ಲಿ.

146
00:10:26,710 --> 00:10:29,960
>> ನನ್ನ ಹೆಸರನ್ನು ರಾಬ್ ಬೌಡೆನ್ ಆಗಿದೆ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.