1
00:00:00,000 --> 00:00:03,388
>> [ಸಂಗೀತ]

2
00:00:03,388 --> 00:00:05,104

3
00:00:05,104 --> 00:00:06,020
ಡೌಗ್ LLOYD: ಸರಿ.

4
00:00:06,020 --> 00:00:07,680
ಒಂದೇ ಕೆಲಸ
ಅಸ್ಥಿರ ಸಾಕಷ್ಟು ಮೋಜು.

5
00:00:07,680 --> 00:00:09,500
ಆದರೆ ನಾವು ನೀವು ಕೆಲಸ
ಅಸ್ಥಿರ ಬಹಳಷ್ಟು,

6
00:00:09,500 --> 00:00:12,760
ಆದರೆ ನಾವು ಒಂದು ಗುಂಪೇ ಬಯಸುವುದಿಲ್ಲ
ನಮ್ಮ ಕೋಡ್ ಸುಮಾರು ವಿವಿಧ ಹೆಸರುಗಳಿಂದ ಹಾರುವ?

7
00:00:12,760 --> 00:00:15,980
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸರಣಿಗಳಿವೆ
ನಿಜವಾಗಿಯೂ HANDY ಬರುತ್ತವೆ ಹೋಗುವ.

8
00:00:15,980 --> 00:00:19,510
ಅರೆಸ್ ನಿಜವಾಗಿಯೂ ಮೂಲಭೂತ ದತ್ತಾಂಶ
ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ರಚನೆ

9
00:00:19,510 --> 00:00:20,260
ನೀವು ಬಳಸುವ.

10
00:00:20,260 --> 00:00:24,450
ಅವರು ನಿಜವಾಗಿಯೂ ಉಪಯುಕ್ತ ಆರ್
ಅದರಲ್ಲಿಯೂ, ವಿಶೇಷವಾಗಿ ಸಿಎಸ್ 50, ನೋಡಿ, ಎಂದು.

11
00:00:24,450 --> 00:00:27,870
>> ನಾವು ಹಿಡಿದಿಡಲು ಸರಣಿಗಳ ಬಳಸಲು
ಅದೇ ದಶಮಾಂಶ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳನ್ನು

12
00:00:27,870 --> 00:00:29,830
ಸಮೀಪದ ಮೆಮೊರಿ ಸ್ಥಳಗಳಲ್ಲಿ.

13
00:00:29,830 --> 00:00:32,430
ಅದು ಇಲ್ಲಿದೆ, ಹೇಳಲು ಹೊಂದಿದೆ
ರೀತಿಯಲ್ಲಿ ನಾವು ಗುಂಪು ಮಾಡಬಹುದು

14
00:00:32,430 --> 00:00:35,430
ಒಟ್ಟಿಗೆ ಪೂರ್ಣಾಂಕಗಳ ಕನಸುಗಳಿವೆ
ಮೆಮೊರಿ ಅಥವಾ ಪಾತ್ರಗಳ ಒಂದು ಗುಂಪೇ

15
00:00:35,430 --> 00:00:38,270
ಅಥವಾ ನಿಜವಾಗಿಯೂ ಮೆಮೊರಿ ತೇಲುತ್ತದೆ
ಒಟ್ಟಾಗಿ ಮತ್ತು ಕೆಲಸ

16
00:00:38,270 --> 00:00:41,930
ಅವುಗಳನ್ನು ಪ್ರತಿ ಬಿಟ್ಟುಕೊಡಲು ಮಾಡದೆಯೇ
ಒಂದು ತನ್ನದೇ ಆದ ಅನನ್ಯ ಹೆಸರು, ಮಾಡಬಹುದು

17
00:00:41,930 --> 00:00:44,500
ಸ್ವಲ್ಪ ನಂತರ ತೊಡಕಿನ ಪಡೆಯಿರಿ.

18
00:00:44,500 --> 00:00:48,130
>> ಈಗ, ಒಂದು ರೀತಿಯಲ್ಲಿ ರಚನೆಗಳು ಸದೃಶವೆಂದು ಗೆ
ನಿಮ್ಮ ಸ್ಥಳೀಯ ಪೋಸ್ಟ್ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು ಹೊಂದಿದೆ

19
00:00:48,130 --> 00:00:49,000
ಎರಡನೇ ಕಚೇರಿ.

20
00:00:49,000 --> 00:00:51,820
ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಳಕೆಯಿಂದ
ಮತ್ತು ಕೇವಲ ನಿಮ್ಮ ಕಣ್ಣುಗಳನ್ನು ಮುಚ್ಚಿ

21
00:00:51,820 --> 00:00:54,120
ನಿಮ್ಮ ಮನಸ್ಸಿನಲ್ಲಿ ಕಲ್ಪಿಸಿಕೊಳ್ಳಲು
ನಿಮ್ಮ ಸ್ಥಳೀಯ ಅಂಚೆ ಕಚೇರಿ.

22
00:00:54,120 --> 00:00:57,160
ಸಾಮಾನ್ಯವಾಗಿ, ಹೆಚ್ಚಿನ ಪೋಸ್ಟ್ನಲ್ಲಿ
ಕಚೇರಿಗಳು, ದೊಡ್ಡ ಬ್ಯಾಂಕ್ ಇಲ್ಲ

23
00:00:57,160 --> 00:01:00,490
ಗೋಡೆಯ ಮೇಲೆ ಒಂದು ಕಚೇರಿ ಪೆಟ್ಟಿಗೆಗಳು.

24
00:01:00,490 --> 00:01:03,510
>> ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಒಂದು ದೈತ್ಯ ಬ್ಲಾಕ್ ಆಗಿದೆ
ಸಮೀಪದ ಮೆಮೊರಿ,

25
00:01:03,510 --> 00:01:06,120
ಮೇಲ್ ಅದೇ ರೀತಿಯಲ್ಲಿ
ನಿಮ್ಮ ಅಂಚೆ ಕಚೇರಿಯಲ್ಲಿ ಬ್ಯಾಂಕ್

26
00:01:06,120 --> 00:01:11,230
ಒಂದು ದೊಡ್ಡ ಜಾಗವನ್ನು ಮೇಲೆ
ಅಂಚೆ ಕಚೇರಿಯ ಗೋಡೆಯ.

27
00:01:11,230 --> 00:01:15,750
ರಚನೆಗಳು, ಸಣ್ಣ ಆಗಿ ವಿಭಜನೆ ಮಾಡಲಾಗಿದೆ
ಒಂದೇ ಜಾಗದಲ್ಲಿ ಗಾತ್ರದ ಬ್ಲಾಕ್ಗಳನ್ನು

28
00:01:15,750 --> 00:01:19,930
ಇದು ಪ್ರತಿ, ಒಂದು ಅಂಶ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ
ಅದೇ ರೀತಿಯಲ್ಲಿ ಪೋಸ್ಟ್ ಗೋಡೆಯ ಎಂದು

29
00:01:19,930 --> 00:01:23,840
ಕಚೇರಿ, ಸಣ್ಣ ಆಗಿ ವಿಭಜನೆ ಮಾಡಲಾಗಿದೆ
ಒಂದೇ ಜಾಗದಲ್ಲಿ ಗಾತ್ರದ ಬ್ಲಾಕ್ಗಳನ್ನು

30
00:01:23,840 --> 00:01:27,560
ಇದು ನಾವು ಒಂದು ಪಿಒ ಮಾಡಬಹುದು ಬಾಕ್ಸ್ ಕರೆ.

31
00:01:27,560 --> 00:01:31,650
ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ಮಾಡಬಹುದು
, ಡೇಟಾ ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ಸಂಗ್ರಹಿಸಲು

32
00:01:31,650 --> 00:01:37,540
ಪ್ರತಿ ಪಿಒ ಮಾಡಬಹುದು ಬಾಕ್ಸ್ ಸಾಧ್ಯವಾಗುತ್ತದೆ ಕೇವಲ
ಮೇಲ್ ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ಹಿಡಿದಿಡಲು.

33
00:01:37,540 --> 00:01:41,540
>> ಪ್ರತಿಯೊಂದು ಅಂಶ ಶೇಖರಿಸಿಡಬಹುದು ಏನು
ಸರಣಿ ಅದೇ ಅಕ್ಷಾಂಶ ಅಸ್ಥಿರ ಆಗಿದೆ

34
00:01:41,540 --> 00:01:45,300
ಇಂತಹ ಕೇವಲ ಇಂಟ್ ಅಥವಾ ಅಕ್ಷರ, ಕೌಟುಂಬಿಕತೆ,
ನಿಮ್ಮ ಕಚೇರಿ ಪೆಟ್ಟಿಗೆಯೊಂದನ್ನು ಚಿತ್ರದಲ್ಲಿರುವಂತೆ

35
00:01:45,300 --> 00:01:47,300
ನೀವು ಕೇವಲ ವಿಷಯಗಳನ್ನು ಹೊಂದುವುದು
ಇದೇ ರೀತಿಯ,

36
00:01:47,300 --> 00:01:50,430
ಅಂತಹ ಅಕ್ಷರಗಳನ್ನು ಅಥವಾ ಚಿಕ್ಕ ಪೊಟ್ಟಣಗಳಲ್ಲಿ ಎಂದು.

37
00:01:50,430 --> 00:01:55,050
ಕೊನೆಯದಾಗಿ, ನಾವು ಪ್ರತಿಯೊಂದು ಅಂಶ ಪ್ರವೇಶಿಸಬಹುದು
ನೇರವಾಗಿ ಸೂಚ್ಯಂಕ ಮೂಲಕ ರಚನೆಯ

38
00:01:55,050 --> 00:01:59,770
ನಮ್ಮ ಪೋಸ್ಟ್ ಆಫೀಸ್ ಪ್ರವೇಶಿಸಬಹುದು ಕೇವಲ
ತನ್ನ ಅಂಚೆಪೆಟ್ಟಿಗೆ ಸಂಖ್ಯೆಯನ್ನು ತಿಳಿದುಕೊಂಡು ಬಾಕ್ಸ್.

39
00:01:59,770 --> 00:02:02,750
ಆಶಾದಾಯಕವಾಗಿ, ಸಾದೃಶ್ಯವು
ನಿಮ್ಮ ತಲೆ ಪಡೆಯಲು ಸಹಾಯ

40
00:02:02,750 --> 00:02:05,540
ರಚನೆಗಳು ಕಲ್ಪನೆಯನ್ನು ಸುಮಾರು
ಯಾವುದೋ ಸದೃಶವಾಗಿರುತ್ತದೆ

41
00:02:05,540 --> 00:02:08,400
ನೀವು ಬಹುಶಃ ಎಂದು
ಈಗಾಗಲೇ ಪರಿಚಿತ.

42
00:02:08,400 --> 00:02:13,182
>> ಸಿ, ವ್ಯೂಹದ ಅಂಶಗಳು
1 ರಿಂದ 0 ದಿಂದ ಆರಂಭಿಸಿ ಸೂಚ್ಯಂಕದೊಡನೆ.

43
00:02:13,182 --> 00:02:14,390
ಮತ್ತು ಈ ನಿಜವಾಗಿಯೂ ಮುಖ್ಯ.

44
00:02:14,390 --> 00:02:18,530
ಏಕೆ ನಾವು ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ಇದು, ಸಿಎಸ್ 50,
ಆಗಾಗ್ಗೆ ಮತ್ತು ಏಕೆ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು

45
00:02:18,530 --> 00:02:22,150
0 ರಿಂದ ಎಣಿಕೆ ಮಾಡುತ್ತದೆ, ಆಗಿದೆ
ಏಕೆಂದರೆ ಸಿ ರಚನೆಯ

46
00:02:22,150 --> 00:02:24,660
ಯಾವಾಗಲೂ 0 ಆರಂಭಗೊಂಡು ಇದು ಅನುಕ್ರಮಣಿಕೆ,.

47
00:02:24,660 --> 00:02:28,730
ಒಂದು ಶ್ರೇಣಿಯನ್ನು N ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಆದ್ದರಿಂದ,
ಆ ರಚನೆಯ ಮೊದಲ ಅಂಶ

48
00:02:28,730 --> 00:02:32,960
, ಸೂಚ್ಯಂಕ 0 ನಲ್ಲಿ ಇದೆ ಮತ್ತು
ರಚನೆಯ ಕೊನೆಯ ಅಂಶ

49
00:02:32,960 --> 00:02:36,610
ಸೂಚ್ಯಂಕ ಎನ್ ಮೈನಸ್ 1 ಇದೆ.

50
00:02:36,610 --> 00:02:43,160
ಮತ್ತೆ, ನಲ್ಲಿ N ಅಂಶಗಳನ್ನು ಇಲ್ಲ ವೇಳೆ ನಮ್ಮ
ರಚನೆಯ ಕಳೆದ ಸೂಚ್ಯಂಕ ಎನ್ ಮೈನಸ್ 1.

51
00:02:43,160 --> 00:02:46,820
>> ಆದ್ದರಿಂದ ನಮ್ಮ ರಚನೆಯ 50 ಅಂಶಗಳನ್ನು ಹೊಂದಿದ್ದರೆ
ಮೊದಲ ಅಂಶ, ಸೂಚ್ಯಂಕ 0 ನಲ್ಲಿ ಇದೆ

52
00:02:46,820 --> 00:02:51,060
ಮತ್ತು ಕೊನೆಯ ಅಂಶ
ಸೂಚ್ಯಂಕ 49 ಇದೆ.

53
00:02:51,060 --> 00:02:53,940
ದುರದೃಷ್ಟವಶಾತ್, ಅಥವಾ ಅದೃಷ್ಟವಶಾತ್,
ನಿಮ್ಮ ದೃಷ್ಟಿಕೋನದಿಂದ ಅವಲಂಬಿಸಿ

54
00:02:53,940 --> 00:02:56,170
ಸಿ ಇಲ್ಲಿ ಬಹಳ ಸಹನಶೀಲ ಆಗಿದೆ.

55
00:02:56,170 --> 00:02:59,480
ಇದು ನಿಮ್ಮನ್ನು ತಡೆಯುವುದಿಲ್ಲ ಕಾಣಿಸುತ್ತದೆ
ನಿಮ್ಮ ರಚನೆಯ ದಾಟಿ ಹೋಗದಂತೆ.

56
00:02:59,480 --> 00:03:03,080
ನೀವು ಮೈನಸ್ ಪ್ರವೇಶಿಸಬಹುದು
ನಿಮ್ಮ ರಚನೆಯ 3 ಅಂಶ

57
00:03:03,080 --> 00:03:07,400
ಅಥವಾ ನಿಮ್ಮ ರಚನೆಯ 59 ನೇ ಅಂಶ
ನಿಮ್ಮ ರಚನೆಯ ಕೇವಲ 50 ಅಂಶಗಳನ್ನು ಹೊಂದಿದೆ ವೇಳೆ.

58
00:03:07,400 --> 00:03:11,060
ಇದು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ನಿಲ್ಲುವುದಿಲ್ಲ
ಕಂಪೈಲ್ ಆದರೆ ರನ್ ಸಮಯದಲ್ಲಿ,

59
00:03:11,060 --> 00:03:14,350
ನೀವು ಎದುರಿಸಬೇಕಾಗುತ್ತದೆ
ಭೀತಿಗೊಳಿಸುವ ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ

60
00:03:14,350 --> 00:03:17,460
ನೀವು ಮೆಮೊರಿ ಪ್ರವೇಶಿಸಲು ಆರಂಭಿಸಲು
ಎಂದು ಏನು ಪರಿಧಿಯಿಂದ ಹೊರಗೆ ಆಗಿದೆ

61
00:03:17,460 --> 00:03:19,260
ನೀವು ನೀಡಲು ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಕೇಳಿದರು.

62
00:03:19,260 --> 00:03:21,250
ಆದ್ದರಿಂದ ಜಾಗರೂಕರಾಗಿರಿ.

63
00:03:21,250 --> 00:03:23,120
>> ಏನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಮಾಡುತ್ತದೆ
ಘೋಷಣೆ ರೀತಿ?

64
00:03:23,120 --> 00:03:26,940
ನಾವು ಅಸ್ತಿತ್ವಕ್ಕೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಕೋಡ್ ಇಲ್ಲ
ಹಾಗೆ ನಾವು ಯಾವುದೇ ಇತರ ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ಕೋಡ್?

65
00:03:26,940 --> 00:03:31,250
ಮೂರು ಭಾಗಗಳಲ್ಲಿ ಗುಂಪಿಗೆ ಇವೆ
ಒಂದು ರೀತಿಯ declaration--, ಹೆಸರು,

66
00:03:31,250 --> 00:03:31,880
ಮತ್ತು ಗಾತ್ರ.

67
00:03:31,880 --> 00:03:34,088
ಈ ಹೋಲುತ್ತದೆ
ವೇರಿಯಬಲ್ ಘೋಷಣೆಯನ್ನು ಅಂಗೀಕರಿಸಿತು

68
00:03:34,088 --> 00:03:36,970
ಕೇವಲ ಒಂದು ರೀತಿಯ ಮತ್ತು ಒಂದು ಹೆಸರು,
ಎಂಬ ಗಾತ್ರ ಅಂಶ

69
00:03:36,970 --> 00:03:39,860
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವಿಶೇಷ ಸಂದರ್ಭದಲ್ಲಿ,
ನಾವು ಅವುಗಳಲ್ಲಿ ಒಂದು ಗುಂಪೇ ಪಡೆಯುತ್ತಿದ್ದಾರೆ ಏಕೆಂದರೆ

70
00:03:39,860 --> 00:03:41,830
ಅದೇ ಸಮಯದಲ್ಲಿ.

71
00:03:41,830 --> 00:03:45,560
>> ಆದ್ದರಿಂದ ರೀತಿಯ ವೇರಿಯಬಲ್ ಯಾವ ರೀತಿಯ ನೀವು
ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ಬಯಸುತ್ತೇನೆ.

72
00:03:45,560 --> 00:03:47,150
ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಅದನ್ನು ಬಯಸುತ್ತೀರಾ?

73
00:03:47,150 --> 00:03:49,010
ನಂತರ, ನಿಮ್ಮ ಡೇಟಾವನ್ನು ರೀತಿಯ ಇಂಟ್ ಇರಬೇಕು.

74
00:03:49,010 --> 00:03:51,760
ನೀವು ಒಂದು ಎಂದು ಬಯಸುತ್ತೀರಾ
ಡಬಲ್ಸ್ ಅಥವಾ ಫ್ಲೋಟ್ಗಳು ಶ್ರೇಣಿಯನ್ನು?

75
00:03:51,760 --> 00:03:54,545
ಡೇಟಾ ಪ್ರಕಾರ ಎರಡು ಅಥವಾ ಚಲಿಸುವಂತೆ ಮಾಡಬೇಕು.

76
00:03:54,545 --> 00:03:56,420
ಹೆಸರೇನು ನೀವು
ನಿಮ್ಮ ರಚನೆಯ ಕರೆಯಲು ಬಯಸುತ್ತೇನೆ.

77
00:03:56,420 --> 00:04:00,970
ಈ ದೈತ್ಯ ಹೆಸರಿಸಲು ಏನು ಬಯಸುತ್ತೀರಿ
ಪೂರ್ಣಾಂಕಗಳ ಅಥವಾ ಫ್ಲೋಟ್ಗಳು ಅಥವಾ ಅಕ್ಷರಗಳನ್ನು ಬ್ಯಾಂಕ್

78
00:04:00,970 --> 00:04:03,250
ಅಥವಾ ಡಬಲ್ಸ್, ಅಥವಾ ಯಾವುದೇ ನೀವು?

79
00:04:03,250 --> 00:04:04,700
ಏನು ನೀವು ಕರೆ ಮಾಡಲು ಬಯಸುತ್ತೀರಿ?

80
00:04:04,700 --> 00:04:06,110
ವಿವರಣಾತ್ಮಕ ಸಾಕಷ್ಟು ಸ್ವಯಂ.

81
00:04:06,110 --> 00:04:08,610
>> ಹೋಗುತ್ತದೆ ಕೊನೆಯದಾಗಿ, ಗಾತ್ರ,
ಚದರ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಒಳಗೆ,

82
00:04:08,610 --> 00:04:12,180
ಎಷ್ಟು ಅಂಶಗಳನ್ನು ನೀವು ಬಯಸುವ
ನಿಮ್ಮ ಶ್ರೇಣಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಹಾಗೆ.

83
00:04:12,180 --> 00:04:13,530
ನೀವು ಎಷ್ಟು ಪೂರ್ಣಾಂಕಗಳ ಬಯಸುತ್ತೀರಿ?

84
00:04:13,530 --> 00:04:15,570
ನೀವು ಎಷ್ಟು ಫ್ಲೋಟ್ಗಳು ಬಯಸುತ್ತೀರಿ?

85
00:04:15,570 --> 00:04:19,070
>> ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ವಿದ್ಯಾರ್ಥಿ ಶ್ರೇಣಿಗಳನ್ನು 40 ಇಂಟ್.

86
00:04:19,070 --> 00:04:26,020
ಈ ವಿದ್ಯಾರ್ಥಿ ಎಂಬ ರಚನೆಯ ಘೋಷಿಸುತ್ತದೆ
40 ಪೂರ್ಣಾಂಕಗಳನ್ನು ಒಳಗೊಂಡಿದ್ದು ಇದು ಶ್ರೇಣಿಗಳನ್ನು,.

87
00:04:26,020 --> 00:04:28,180
ಪ್ರೆಟಿ ಬರೆದಿತ್ತು ನಾನು ಭಾವಿಸುತ್ತೇವೆ.

88
00:04:28,180 --> 00:04:29,330
ಇಲ್ಲಿದೆ ಮತ್ತೊಂದು ಉದಾಹರಣೆ.

89
00:04:29,330 --> 00:04:31,560
ಡಬಲ್ ಮೆನು ಬೆಲೆಗಳು 8.

90
00:04:31,560 --> 00:04:34,610
ಈ ಎಂಬ ರಚನೆಯ ಸೃಷ್ಟಿಸುತ್ತದೆ
ಒಳಗೊಂಡಿದೆ ಮೆನು ಬೆಲೆಗಳು

91
00:04:34,610 --> 00:04:38,300
ಎಂಟು ಡಬಲ್ಸ್ ಮೆಮೊರಿ ಕೋಣೆಯ.

92
00:04:38,300 --> 00:04:42,000

93
00:04:42,000 --> 00:04:45,750
>> ನೀವು ಪ್ರತಿ ಅಂಶ ಭಾವಿಸಿದರೆ
ಶೈಲಿಯ ಮಾಹಿತಿಯನ್ನು ಮಾದರಿಯ ಒಂದು ಶ್ರೇಣಿಯನ್ನು,

94
00:04:45,750 --> 00:04:49,860
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ಒಂದು ಅಂಶ
ರೀತಿಯ ಇಂಟ್ ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಅದೇ ರೀತಿಯಲ್ಲಿ ನೀವು

95
00:04:49,860 --> 00:04:52,770
ಯಾವುದೇ ಯೋಚಿಸುವುದಿಲ್ಲ
ರೀತಿಯ ಇಂಟ್ ವೇರಿಯಬಲ್,

96
00:04:52,770 --> 00:04:56,440
ಎಲ್ಲಾ ಪರಿಚಿತ ಕಾರ್ಯಾಚರಣೆ ನಾವು
ಕಾರ್ಯಾಚರಣೆ ರಲ್ಲಿ ಹಿಂದೆ ಚರ್ಚಿಸಿದ

97
00:04:56,440 --> 00:04:58,270
ವೀಡಿಯೊ ಅರ್ಥದಲ್ಲಿ ಮಾಡುತ್ತದೆ.

98
00:04:58,270 --> 00:05:01,620
ಇಲ್ಲಿ, ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ
Truthtable ಎಂಬ Booleans ಆಫ್,

99
00:05:01,620 --> 00:05:05,590
ಇದು 10 Booleans ಕೊಠಡಿ ಒಳಗೊಂಡಿದೆ.

100
00:05:05,590 --> 00:05:09,650
>> ನಂತರ, ಕೇವಲ ನಾವು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಇಷ್ಟ
ರೀತಿಯ ಯಾವುದೇ ವೇರಿಯೇಬಲ್ ಒಂದು ಮೌಲ್ಯವನ್ನು

101
00:05:09,650 --> 00:05:13,470
ಬೂಲಿಯನ್, ನಾವು ಏನೋ ಹೇಳಬಹುದು
Truthtable ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ರೀತಿಯ

102
00:05:13,470 --> 00:05:18,040
ನಾವು ಸೂಚಿಸಲು ಹೇಗೆ ಇದು 2,
ಇದು ಸತ್ಯ ಮೇಜಿನ ಅಂಶ?

103
00:05:18,040 --> 00:05:20,350
ಮೂರನೇ ಅಂಶ
ಸತ್ಯ ಟೇಬಲ್, ನೆನಪು ಏಕೆಂದರೆ,

104
00:05:20,350 --> 00:05:21,800
ನಾವು 0 ರಿಂದ ಲೆಕ್ಕ ನೀವು.

105
00:05:21,800 --> 00:05:25,690
ಆದ್ದರಿಂದ ನಾವು ಸೂಚಿಸಲು ಹೇಗೆ
ಸತ್ಯ ಟೇಬಲ್ ಮೂರನೇ ಅಂಶ.

106
00:05:25,690 --> 00:05:28,680
Truthtable 2, ಸುಳ್ಳು ಸಮನಾಗಿರುತ್ತದೆ
ಕೇವಲ ನಾವು declare-- ಹಾಗೆ

107
00:05:28,680 --> 00:05:33,560
ಅಥವಾ ನಾವು ಯಾವುದೇ, ಬದಲಿಗೆ, ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ಬೂಲಿಯನ್ ರೀತಿಯ ವೇರಿಯಬಲ್ ಸುಳ್ಳು ಎಂದು.

108
00:05:33,560 --> 00:05:35,050
>> ನಾವು ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಬಳಸಬಹುದು.

109
00:05:35,050 --> 00:05:39,000
(truthtable 7 == ವೇಳೆ
ಹೇಳಲು ಇದು ನಿಜವಾದ),

110
00:05:39,000 --> 00:05:42,370
ಎಂಟನೇ ಅಂಶ ವೇಳೆ
Truthtable ಆಫ್, ಸತ್ಯ

111
00:05:42,370 --> 00:05:46,760
ಬಹುಶಃ ನಾವು ಒಂದು ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ ಬಯಸುವ
ಬಳಕೆದಾರ, printf ("ಸರಿ! ಎನ್") ಗೆ ;.

112
00:05:46,760 --> 00:05:50,290
ಆ Truthtable ಹೇಳಲು ನಮಗೆ ಕಾರಣವಾಗುತ್ತದೆ
10 ಬಲ, ನಿಜವಾದ ಸಮ?

113
00:05:50,290 --> 00:05:53,590
ಸರಿ, ನಾನು ಮಾಡಬಹುದು, ಆದರೆ ಇದು ಬಹಳ ಇಲ್ಲಿದೆ
ಅಪಾಯಕಾರಿ, ಏಕೆಂದರೆ, ಮರೆಯದಿರಿ

114
00:05:53,590 --> 00:05:56,260
ನಾವು 10 Booleans ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿವೆ.

115
00:05:56,260 --> 00:06:02,340
ಆದ್ದರಿಂದ ಅತಿ ಸೂಚ್ಯಂಕ ಎಂದು
ಕಂಪೈಲರ್ ನಮಗೆ 9 ನೀಡಿದೆ.

116
00:06:02,340 --> 00:06:06,010
>> ಈ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್, ಆದರೆ
ವೇಳೆ ಮೆಮೊರಿ ಯಾವುದೋ

117
00:06:06,010 --> 00:06:09,110
ಅಲ್ಲಿ ನಾವು ಎಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
Truthtable 10 ಹೋಗಲು ನಿರೀಕ್ಷಿಸಬಹುದು,

118
00:06:09,110 --> 00:06:13,980
ನಾವು ಒಂದು ಸೆಗ್ಮೆಂಟೇಶನ್ ದೋಷಕ್ಕೆ ಎದುರಿಸಿದರು. ನಾವು
ಅದನ್ನು ದೂರ ಪಡೆಯಲು, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ,

119
00:06:13,980 --> 00:06:14,710
ಬಹಳ ಅಪಾಯಕಾರಿ.

120
00:06:14,710 --> 00:06:19,759
ಹಾಗಾಗಿ ನಾನು ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವೆ ಕಾನೂನು C ಆಗಿರುತ್ತದೆ,
ಆದರೆ ಅಗತ್ಯವಾಗಿ ಉತ್ತಮ ನಡೆಯನ್ನು.

121
00:06:19,759 --> 00:06:22,300
ಈಗ, ನೀವು ಘೋಷಿಸಿದ ಮತ್ತು
ಏಕಕಾಲದಲ್ಲಿ ಒಂದು ಸರಣಿ ಆರಂಭಿಸಲು,

122
00:06:22,300 --> 00:06:23,960
ವಾಸ್ತವವಾಗಿ ಒಂದು ಸುಂದರ ಇಲ್ಲ
ವಿಶೇಷ ವಾಕ್ಯ ನೀವು

123
00:06:23,960 --> 00:06:26,250
ಶ್ರೇಣಿಯನ್ನು ಅಪ್ ತುಂಬಲು ಬಳಸಬಹುದು
ತನ್ನ ಆರಂಭಿಕ ಮೌಲ್ಯಗಳು.

124
00:06:26,250 --> 00:06:30,130
ಇದು ತೊಡಕಿನ ಪಡೆಯುವುದು
, ಗಾತ್ರ 100 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು

125
00:06:30,130 --> 00:06:33,430
ತದನಂತರ ಹೇಳಬೇಕು, ಅಂಶ 0
ಈ ಸಮನಾಗಿರುತ್ತದೆ; ಅಂಶ 1 ಈ ಸಮನಾಗಿರುತ್ತದೆ;

126
00:06:33,430 --> 00:06:34,850
ಅಂಶ 2 ಎಂದು ಸಮನಾಗಿರುತ್ತದೆ.

127
00:06:34,850 --> 00:06:36,370
ಬಲ, ಪಾಯಿಂಟ್ ಎಂದರೇನು?

128
00:06:36,370 --> 00:06:39,470
>> ಇದು ಒಂದು ಸಣ್ಣ ಶ್ರೇಣಿಯನ್ನು ಆಗಿದ್ದರೆ, ನೀವು
ಈ ರೀತಿಯ ಇಲ್ಲ.

129
00:06:39,470 --> 00:06:44,360
Bool truthtable 3 ಮುಕ್ತ ಸಮನಾಗಿರುತ್ತದೆ
ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ನಂತರ ಅಲ್ಪವಿರಾಮ

130
00:06:44,360 --> 00:06:48,060
ಅಂಶಗಳ ಪಟ್ಟಿಯನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು
ನೀವು ಶ್ರೇಣಿಯಲ್ಲಿನ ಹಾಕಲು ಬಯಸುವ.

131
00:06:48,060 --> 00:06:50,520
ನಂತರ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ ಅರ್ಧವಿರಾಮ ಮುಚ್ಚಿ.

132
00:06:50,520 --> 00:06:53,910
ಈ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ
ಗಾತ್ರ Truthtable ಎಂಬ ಮೂರು,

133
00:06:53,910 --> 00:06:56,090
ಅಂಶಗಳನ್ನು ಸುಳ್ಳು ನಿಜ, ಮತ್ತು ನೈಜ ಜೊತೆ.

134
00:06:56,090 --> 00:06:59,270
ಮತ್ತು ವಾಸ್ತವವಾಗಿ, ನಿದರ್ಶನವೆಂದು
ನಾನು ಇಲ್ಲಿ ವಾಕ್ಯ

135
00:06:59,270 --> 00:07:03,350
ಮಾಡುವ ಒಂದೇ
ಕೆಳಗೆ ನೀಡಲಾಗಿರುವ ಪ್ರತ್ಯೇಕ ಅಂಶ ವಾಕ್ಯ.

136
00:07:03,350 --> 00:07:09,380
ಕೋಡಿಂಗ್ ಈ ಎರಡು ರೀತಿಯಲ್ಲಿ ಎಂದು
ಅದೇ ಶ್ರೇಣಿಯನ್ನು ತಯಾರಿಸಲು.

137
00:07:09,380 --> 00:07:11,740
>> ಹಾಗೆಯೇ, ನಾವು ಮರಳಿ ಮಾಡಬಹುದು
ಅಂಶಗಳನ್ನು ಎಲ್ಲಾ ಮೇಲೆ

138
00:07:11,740 --> 00:07:15,400
ಒಂದು ಲೂಪ್ ಅನ್ನು ಒಂದು ಶ್ರೇಣಿಯನ್ನು, ಇದು ನಗರದಲ್ಲಿ
ವಾಸ್ತವವಾಗಿ, ಒಂದು ಬಲವಾಗಿ ಶಿಫಾರಸು

139
00:07:15,400 --> 00:07:16,790
ಮನೆಯಲ್ಲಿಯೇ ವ್ಯಾಯಾಮ.

140
00:07:16,790 --> 00:07:20,720
ಹೇಗೆ ನೀವು ರಚನೆಯ ರಚಿಸಲು ಇಲ್ಲ
100 ಪೂರ್ಣಾಂಕಗಳ, ಅಲ್ಲಿ

141
00:07:20,720 --> 00:07:23,477
ರಚನೆಯ ಪ್ರತಿ ಅಂಶ ಅದರ ಸೂಚ್ಯಂಕ?

142
00:07:23,477 --> 00:07:26,560
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾವು 100 ಸರಣಿ
ಪೂರ್ಣಾಂಕಗಳು ಮತ್ತು ಮೊದಲ ಅಂಶ,

143
00:07:26,560 --> 00:07:27,790
ನಾವು 0 ಹಾಕಲು ಬಯಸುವ.

144
00:07:27,790 --> 00:07:29,810
ಎರಡನೇ ಅಂಶ, ನಾವು 1 ಹಾಕಲು ಬಯಸುವ.

145
00:07:29,810 --> 00:07:33,319
ಮೂರನೇ ಅಂಶ, ನಾವು ಬಯಸುವ
2 ಹಾಕಲು; ಹೀಗೆ ಹೀಗೆ.

146
00:07:33,319 --> 00:07:35,360
ಒಂದು ಒಳ್ಳೆಯ ಇಲ್ಲಿದೆ
ಮನೆಯಲ್ಲಿಯೇ ವ್ಯಾಯಾಮ ಮಾಡಲು.

147
00:07:35,360 --> 00:07:38,190

148
00:07:38,190 --> 00:07:40,220
>> ಇಲ್ಲಿ, ಇದು ಕಂಡುಬರುತ್ತಿಲ್ಲ
ಹಾಗೆ ತುಂಬಾ ಬದಲಾಗಿದೆ.

149
00:07:40,220 --> 00:07:44,170
ಆದರೆ ನಡುವಿನ ಗಮನಕ್ಕೆ
ಚೌಕಾಕಾರದ, ಈ ಬಾರಿ,

150
00:07:44,170 --> 00:07:45,830
ನಾನು ವಾಸ್ತವವಾಗಿ ಸಂಖ್ಯೆ ಬಿಟ್ಟು ಬಂದಿದೆ.

151
00:07:45,830 --> 00:07:48,000
ನೀವು ಬಳಸುತ್ತಿದ್ದರೆ ಈ
ವಿಶೇಷ ನಿದರ್ಶನವೆಂದು

152
00:07:48,000 --> 00:07:50,380
ವಾಕ್ಯ ಒಂದು ರಚಿಸಲು
ಶ್ರೇಣಿಯನ್ನು, ನೀವು ವಾಸ್ತವವಾಗಿ ಇಲ್ಲ

153
00:07:50,380 --> 00:07:53,491
ಗಾತ್ರ ಸೂಚಿಸಲು ಅಗತ್ಯವಿದೆ
ರಚನೆಯ ಮೊದಲೇ.

154
00:07:53,491 --> 00:07:55,740
ಕಂಪೈಲರ್ ಸಾಕಷ್ಟು ಸ್ಮಾರ್ಟ್ ಆಗಿದೆ
ವಾಸ್ತವವಾಗಿ ಆ ತಿಳಿಯಲು

155
00:07:55,740 --> 00:07:58,980
ಗಾತ್ರದ 3 ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಬಯಸುವ
ನೀವು ಮೂರು ಅಂಶಗಳನ್ನು ಹಾಕಲು ಕಾರಣ

156
00:07:58,980 --> 00:08:00,640
ಸಮ ಚಿಹ್ನೆಯ ಬಲಭಾಗದಲ್ಲಿ.

157
00:08:00,640 --> 00:08:04,140
ನೀವು ನಾಲ್ಕು ಇರಿಸಿದರು, ಅದು ಹೊಂದಿರುತ್ತದೆ
ನೀವು ಗಾತ್ರ ನಾಲ್ಕು ಒಂದು ಸತ್ಯ ಟೇಬಲ್ ನೀಡಿದ;

158
00:08:04,140 --> 00:08:06,270
ಹೀಗೆ ಹೀಗೆ.

159
00:08:06,270 --> 00:08:09,380
>> ಅರೆಸ್ ಒಂದು ಸೀಮಿತವಾಗಿಲ್ಲ
ಸುಂದರವಾಗಿದೆ ಆಯಾಮ.

160
00:08:09,380 --> 00:08:12,000
ನೀವು ವಾಸ್ತವವಾಗಿ ಅನೇಕ ಹೊಂದಬಹುದು
ಅಡ್ಡ ಸ್ಪೆಸಿಫೈಯರ್ಸ್ ನಿಮ್ಮ ಇಚ್ಚೆಯಂತೆ.

161
00:08:12,000 --> 00:08:16,470
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನೀವು ರಚಿಸಲು ಬಯಸಿದರೆ
ಆಟದ ಯುದ್ದದ ಒಂದು ಬೋರ್ಡ್, ಇದು

162
00:08:16,470 --> 00:08:20,910
ನೀವು ಆಡಿದ ವೇಳೆ, ಎಂದು ಒಂದು ಆಟ
10 ಗ್ರಿಡ್ ಮೂಲಕ 10 ಗೂಟಗಳ ಆಡಲಾಗುತ್ತದೆ,

163
00:08:20,910 --> 00:08:22,450
ನೀವು ಈ ರೀತಿಯ ಒಂದು ರಚನೆಯ ರಚಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

164
00:08:22,450 --> 00:08:26,030
ನೀವು Bool ಹೇಳಬಹುದು
ಯುದ್ಧನೌಕೆ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ 10

165
00:08:26,030 --> 00:08:29,590
ಮುಚ್ಚಿದ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಚದರ
ಬ್ರಾಕೆಟ್ 10 ಚದರ ಬ್ರಾಕೆಟ್ ಮುಚ್ಚಲಾಗಿದೆ.

166
00:08:29,590 --> 00:08:32,710
>> ನಂತರ, ನೀವು ಆಯ್ಕೆ ಮಾಡಬಹುದು
10 ನಿಮ್ಮ ಮನಸ್ಸಿನಲ್ಲಿ ಈ ವ್ಯಾಖ್ಯಾನಿಸುವ

167
00:08:32,710 --> 00:08:35,576
ಜೀವಕೋಶಗಳ 10 ಗ್ರಿಡ್ ಮೂಲಕ.

168
00:08:35,576 --> 00:08:37,409
ಈಗ, ವಾಸ್ತವವಾಗಿ, ನೆನಪಿಗಾಗಿ,
ಇದು ನಿಜವಾಗಿಯೂ ಮಾಡುತ್ತದೆ

169
00:08:37,409 --> 00:08:42,440
, ಒಂದು 100 ಅಂಶ ಉಳಿಯುತ್ತದೆ
ಒಂದೇ ಆಯಾಮದ ರಚನೆಯ.

170
00:08:42,440 --> 00:08:46,070
ಮತ್ತು ಈ, ವಾಸ್ತವವಾಗಿ, ನೀವು ವೇಳೆ ಹೋಗಬಹುದು
ಮೂರು ಆಯಾಮಗಳಲ್ಲಿ ಅಥವಾ ನಾಲ್ಕು ಅಥವಾ ಐದು ಹೊಂದಿವೆ.

171
00:08:46,070 --> 00:08:49,420
ಇದು ನಿಜವಾಗಿಯೂ ಕೇವಲ ಗುಣಿಸಿ ಇಲ್ಲ
indices-- ಎಲ್ಲಾ

172
00:08:49,420 --> 00:08:51,130
ಅಥವಾ ಗಾತ್ರ ಎಲ್ಲಾ
ಒಟ್ಟಿಗೆ specifiers--,

173
00:08:51,130 --> 00:08:53,480
ಮತ್ತು ನೀವು ಕೇವಲ ಒಂದು ಆಯಾಮದ ಪಡೆಯಲು
ಆ ಗಾತ್ರದ ಶ್ರೇಣಿಯನ್ನು.

174
00:08:53,480 --> 00:08:57,090
>> ಆದರೆ ಸಂಘಟನೆಯ ದೃಷ್ಟಿಯಿಂದ ಮತ್ತು
ದೃಶ್ಯೀಕರಣ ಮತ್ತು ಮಾನವ ಗ್ರಹಿಕೆಯ,

175
00:08:57,090 --> 00:08:59,240
ಇದು ಬಹಳಷ್ಟು ಸುಲಭವಾಗುತ್ತದೆ
ಒಂದು ಗ್ರಿಡ್ ಕೆಲಸ

176
00:08:59,240 --> 00:09:02,980
ನೀವು ಆಟದ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ
ಟಿಕ್-ಟ್ಯಾಕ್-ಟೋ ಅಥವಾ ಸಮರ ರೀತಿಯಲ್ಲಿ,

177
00:09:02,980 --> 00:09:05,179
ಅಥವಾ ಸ್ವಲ್ಪ.

178
00:09:05,179 --> 00:09:06,970
ಇದು ಒಂದು ದೊಡ್ಡ ಅಮೂರ್ತತೆ ಇಲ್ಲಿದೆ,
ಬದಲಿಗೆ ಹೊಂದುವ

179
00:09:06,970 --> 00:09:09,340
ಒಂದು ಟಿಕ್-ಟ್ಯಾಕ್-ಟೋ ಬಗ್ಗೆ ಯೋಚಿಸುವುದು
ಒಂಬತ್ತನೆಯ ಒಂದು ಸಾಲಿನಂತೆ ಬೋರ್ಡ್

180
00:09:09,340 --> 00:09:13,810
ಚೌಕಗಳು ಅಥವಾ ಒಂದು ಯುದ್ದದ ಬೋರ್ಡ್
100 ಚೌಕಾಕಾರದ ಒಂದು ಸಾಲಿನಂತೆ.

181
00:09:13,810 --> 00:09:16,010
10 ಗ್ರಿಡ್ ಅಥವಾ ಮೂರು ಒಂದು 10
ಮೂರು ಗ್ರಿಡ್ ಕಾರಣವಿರಬಹುದು

182
00:09:16,010 --> 00:09:17,225
ಬಹಳ ಸುಲಭ ಗ್ರಹಿಸುವ.

183
00:09:17,225 --> 00:09:19,820

184
00:09:19,820 --> 00:09:22,280
>> ಈಗ, ಏನೋ ನಿಜವಾಗಿಯೂ
ರಚನೆಗಳು ಮುಖ್ಯ.

185
00:09:22,280 --> 00:09:25,950
ನಾವು ಪ್ರತಿಯೊಂದು ಚಿಕಿತ್ಸೆ
ಒಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ ರಚನೆಯ ಅಂಶ.

186
00:09:25,950 --> 00:09:27,700
ನಾವು ಹಿಂದೆ ನೋಡಿದ
ನಾವು ನಿಯೋಜಿಸುವ ಮಾಡಲಾಯಿತು

187
00:09:27,700 --> 00:09:32,240
ಕೆಲವು Booleans ನಿಜವಾದ ಮೌಲ್ಯವನ್ನು
ಅಥವಾ ಸಂಭಾವನಾ ಅವುಗಳನ್ನು ಪರೀಕ್ಷೆ.

188
00:09:32,240 --> 00:09:35,960
ಆದರೆ ನಾವು ಸಂಪೂರ್ಣ ಚಿಕಿತ್ಸೆ ಸಾಧ್ಯವಿಲ್ಲ
ಅಸ್ಥಿರ ತಮ್ಮನ್ನು ಸಾಲುಗಳು.

189
00:09:35,960 --> 00:09:41,760
ನಾವು, ಉದಾಹರಣೆಗೆ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಿಯೋಜಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ
ಹುದ್ದೆ ಬಳಸಿಕೊಂಡು ಇನ್ನೊಂದು ಸರಣಿ

190
00:09:41,760 --> 00:09:42,930
ಆಯೋಜಕರು.

191
00:09:42,930 --> 00:09:44,640
ಇದು ಕಾನೂನು ಸಿ ಅಲ್ಲ

192
00:09:44,640 --> 00:09:47,920
>> ನಾವು ಉದಾಹರಣೆಗೆ ಫಾರ್, ಬಯಸಿದರೆ ಏನು
ನಾವು ಉದಾಹರಣೆಯಲ್ಲಿ ಮಾಡುತ್ತಿದ್ದ ಎಂದು

193
00:09:47,920 --> 00:09:50,200
ಇನ್ನೊಂದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ನಕಲು ಎಂದು.

194
00:09:50,200 --> 00:09:53,810
ನಾವು, ನಾವು ವಾಸ್ತವವಾಗಿ ಬಯಸಿದರೆ
ಲಿಂಕುಗಳು ಲೂಪ್ ಬಳಸಬೇಕಾಗುತ್ತದೆ

195
00:09:53,810 --> 00:09:56,550
ಒಂದು ಸಮಯದಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಅಂಶ ಒಂದು.

196
00:09:56,550 --> 00:09:58,700
ನಾನು ಸೇವಿಸುವ ಸ್ವಲ್ಪ ಸಮಯ ತಿಳಿಯಲು.

197
00:09:58,700 --> 00:10:04,022
>> ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾವು ಈ ಒಂದೆರಡು ಹೊಂದಿತ್ತು
ಕೋಡ್ ಸಾಲುಗಳನ್ನು, ಈ ಕೆಲಸ?

198
00:10:04,022 --> 00:10:05,230
ಅಲ್ಲದೆ, ಯಾವುದೇ, ಇದು ಬಲ, ಅಲ್ಲ?

199
00:10:05,230 --> 00:10:07,860
ನಾವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಏಕೆಂದರೆ
ಬಾರ್ ಆಹಾರ ನಿಯೋಜಿಸಲು.

200
00:10:07,860 --> 00:10:09,860
ಆ ಕೆಲಸ ಹಿಂದಿರುಗಬಹುದೆಂದು,
ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಏಕೆಂದರೆ,

201
00:10:09,860 --> 00:10:13,130
ಮತ್ತು ನಾವು ವಿವರಿಸಲಾಗಿದೆ
ಕಾನೂನು ಸಿ ಅಲ್ಲ

202
00:10:13,130 --> 00:10:15,580
>> ಬದಲಾಗಿ, ನಾವು ಬಯಸಿದರೆ
ಆಹಾರ ವಿಷಯಗಳ ನಕಲು

203
00:10:15,580 --> 00:10:18,070
ಏನು ಇದು ಬಾರ್, ಒಳಗೆ
ನಾವು ಇಲ್ಲಿ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ

204
00:10:18,070 --> 00:10:19,970
ನಾವು ಈ ರೀತಿಯ ಒಂದು ವಾಕ್ಯ ಅಗತ್ಯವಿದೆ.

205
00:10:19,970 --> 00:10:24,170
ನಾವು ಒಂದು ಲೂಪ್ ಎಂದು ಹೋಗುತ್ತದೆ
ಜೆ, 5 ವರೆಗೆ 0 ಸಮಾನವಾಗಿರುತ್ತದೆ

206
00:10:24,170 --> 00:10:28,390
ಮತ್ತು ನಾವು ಪ್ರತಿ ಪುನರಾವರ್ತನೆ ಮೇಲೆ ಜೆ ಹೆಚ್ಚಿಸಲು
ಲೂಪ್ ಮತ್ತು ಹಾಗೆ ನಿಗದಿಪಡಿಸಿದ್ದಾರೆ ಅಂಶಗಳನ್ನು.

207
00:10:28,390 --> 00:10:33,360
ಇದು ಬಾರ್ ಕಾರಣವಾಗಬಹುದು
ಎಂಬ ಒಂದು, ಎರಡು, ಮೂರು, ನಾಲ್ಕು, ಐದು,

208
00:10:33,360 --> 00:10:36,730
ಆದರೆ ನಾವು ಈ ಮಾಡಬೇಕು
ನಿಧಾನ ಅಂಶ ಮೂಲಕ ಅಂಶ ರೀತಿಯಲ್ಲಿ,

209
00:10:36,730 --> 00:10:40,009
ಬದಲಿಗೆ ಕೇವಲ ಮೂಲಕ
ಸಂಪೂರ್ಣ ರಚನೆಯ ನಕಲು.

210
00:10:40,009 --> 00:10:42,050
ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್
ಭಾಷೆಗಳು, ಹೆಚ್ಚು ಆಧುನಿಕ,

211
00:10:42,050 --> 00:10:45,610
ನೀವು, ವಾಸ್ತವವಾಗಿ, ಕೇವಲ ಮಾಡಬಹುದು
ವಾಕ್ಯ ಸರಳ ಸಮನಾಗಿರುತ್ತದೆ.

212
00:10:45,610 --> 00:10:49,620
ಆದರೆ ಸಿ, ದುರದೃಷ್ಟವಶಾತ್, ನಾವು ಆರ್
ಹಾಗೆ ಅನುಮತಿಸಲಾಗುವುದಿಲ್ಲ.

213
00:10:49,620 --> 00:10:52,026
>> ಈಗ, ಇನ್ನೊಂದು ಇಲ್ಲ
ನಾನು ಬಗ್ಗೆ ಬಯಸುವ

214
00:10:52,026 --> 00:10:54,650
ರಚನೆಗಳು ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಮಾಡಬಹುದು
ಸ್ವಲ್ಪ ಟ್ರಿಕಿ ಮೊದಲ ಬಾರಿಗೆ ನೀವು

215
00:10:54,650 --> 00:10:55,990
ಅವರೊಂದಿಗೆ ಕೆಲಸ.

216
00:10:55,990 --> 00:10:59,860
ನಾವು ಒಂದು ವಿಡಿಯೋ ಚರ್ಚಿಸಲಾಗಿದೆ
ವೇರಿಯಬಲ್ ವ್ಯಾಪ್ತಿ ಬಗ್ಗೆ,

217
00:10:59,860 --> 00:11:04,940
ನೀವು ಕರೆ ಮಾಡಿದಾಗ ಸಿ ಅತ್ಯಂತ ಚರಾಂಕಗಳ
ಅವುಗಳನ್ನು ಕಾರ್ಯಚಟುವಟಿಕೆಗಳಲ್ಲಿ, ಮೌಲ್ಯ ರವಾನಿಸಲ್ಪಡುತ್ತದೆ.

218
00:11:04,940 --> 00:11:08,620
ನೀವು ಅರ್ಥ ನಿಮಗೆ ನೆನಪಿದೆಯೇ
ಮೌಲ್ಯ ಏನಾದರೂ ಪಾಸ್?

219
00:11:08,620 --> 00:11:12,570
ನಾವು ಪ್ರತಿಯನ್ನು ಮಾಡುತ್ತಿದ್ದೀಯ ಅರ್ಥ
ಅಂಗೀಕಾರವಾದ ಸ್ ವೇರಿಯಬಲ್.

220
00:11:12,570 --> 00:11:16,290
Callee ಕ್ರಿಯೆ ಕ್ರಿಯೆ, ಕೆಲಸ
ಎಂದು, ವೇರಿಯಬಲ್ ಸ್ವೀಕರಿಸಿದ

221
00:11:16,290 --> 00:11:17,730
ವೇರಿಯಬಲ್ ಸ್ವತಃ ಸಿಗಲಿಲ್ಲ.

222
00:11:17,730 --> 00:11:20,850
ಇದು ತನ್ನದೇ ಆದ ಸ್ಥಳೀಯ ಪಡೆಯುತ್ತದೆ
ಅದರ ಪ್ರತಿಯನ್ನು ಕೆಲಸ.

223
00:11:20,850 --> 00:11:24,070
>> ರಚನೆಗಳು, ಸಹಜವಾಗಿ, ಹಾಗೆ
ಈ ನಿಯಮವನ್ನು ಅನುಸರಿಸುವುದಿಲ್ಲ.

224
00:11:24,070 --> 00:11:27,600
ಬದಲಿಗೆ, ನಾವು ಈ ಕರೆಯುವ
ಉಲ್ಲೇಖ ರವಾನಿಸುವುದು.

225
00:11:27,600 --> 00:11:31,360
Callee ವಾಸ್ತವವಾಗಿ
ಶ್ರೇಣಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತಾರೆ.

226
00:11:31,360 --> 00:11:34,207
ಇದು ಬರದಿದ್ದಲ್ಲಿ ಅದರ
ಇದು ಸ್ಥಳೀಯ ಪ್ರತಿಯನ್ನು.

227
00:11:34,207 --> 00:11:36,040
ಮತ್ತು ನೀವು ಭಾವಿಸಿದರೆ
ಇದು, ಈ ಅರ್ಥವಿಲ್ಲ.

228
00:11:36,040 --> 00:11:39,750
ರಚನೆಗಳು ನಿಜವಾಗಿಯೂ ದೊಡ್ಡ, ಅದು
ತುಂಬಾ ಸಮಯ ಮತ್ತು ಶ್ರಮ ಬೇಕಾಗುತ್ತದೆ

229
00:11:39,750 --> 00:11:44,470
ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಪ್ರತಿಯನ್ನು ಮಾಡಲು
100 ಅಥವಾ 1,000 ಅಥವಾ 10,000 ಅಂಶಗಳನ್ನು,

230
00:11:44,470 --> 00:11:48,290
ಇದು ಒಂದು ಇದು ಯೋಗ್ಯವಾಗಿರುವುದಿಲ್ಲ ಎಂದು
ಅದರ ನಕಲನ್ನು ಸ್ವೀಕರಿಸಲು ಕೆಲಸ,

231
00:11:48,290 --> 00:11:51,037
ನಂತರ ಅದನ್ನು ಕೆಲಸ ಮಾಡಬೇಕು, ಮತ್ತು
ನಕಲು ಮಾಡಿದ;

232
00:11:51,037 --> 00:11:53,120
ಇದು ಹೊಂದಿವೆ ಅಗತ್ಯವಿಲ್ಲ
ಇದು ಇನ್ನು ಮುಂದೆ ಕಳೆಯಲು.

233
00:11:53,120 --> 00:11:54,710
>> ಸರಣಿಗಳ ಏಕೆಂದರೆ ಕೆಲವು
ಬೃಹತ್ ಮತ್ತು ತೊಡಕಿನ,

234
00:11:54,710 --> 00:11:56,001
ನಾವು ಉಲ್ಲೇಖ ಮೂಲಕ ಹಾದು.

235
00:11:56,001 --> 00:12:01,210
ನಾವು ಆ ಕಾರ್ಯವನ್ನು ನಂಬಿಕೆ
ಏನು ಮುರಿಯಲು ಇಲ್ಲ ಗೆ.

236
00:12:01,210 --> 00:12:03,010
ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ ಶ್ರೇಣಿಯನ್ನು ಪಡೆಯಲು ಇಲ್ಲ.

237
00:12:03,010 --> 00:12:05,290
ಇದು ತನ್ನದೇ ಆದ ಸ್ಥಳೀಯ ಪ್ರತಿಯನ್ನು ಸಿಗಲಿಲ್ಲ.

238
00:12:05,290 --> 00:12:07,170
>> ಆದ್ದರಿಂದ ಇದರ ಅರ್ಥ ಏನು,
ನಂತರ, ಯಾವಾಗ callee

239
00:12:07,170 --> 00:12:08,970
ರಚನೆಯ ಅಂಶಗಳನ್ನು ಕುಶಲತೆಯಿಂದ?

240
00:12:08,970 --> 00:12:10,780
ಏನಾಗುತ್ತದೆ?

241
00:12:10,780 --> 00:12:13,210
ಈಗ, ನಾವು ಗ್ಲಾಸ್ ಮಾಡುತ್ತೇವೆ
ಏಕೆ ನಿಖರವಾಗಿ ಈ ಮೇಲೆ

242
00:12:13,210 --> 00:12:15,320
, ಏಕೆ ರಚನೆಗಳು ನಡೆಯುತ್ತದೆ
ಉಲ್ಲೇಖವು ರವಾನಿಸಲ್ಪಡುತ್ತದೆ

243
00:12:15,320 --> 00:12:17,810
ಮತ್ತು ಎಲ್ಲವೂ ಮೌಲ್ಯವನ್ನು ರವಾನಿಸಲಾಗಿದೆ.

244
00:12:17,810 --> 00:12:20,470
ಆದರೆ ನಾನು ನೀವು ಭರವಸೆ, ನಾವು ತಿನ್ನುವೆ
ಹಿಂದಿರುಗಿ ನೀವು ಉತ್ತರವನ್ನು ನೀಡುತ್ತದೆ

245
00:12:20,470 --> 00:12:23,750
ನಂತರದ ವಿಡಿಯೋದಲ್ಲಿ ಈ.

246
00:12:23,750 --> 00:12:28,110
>> ಇಲ್ಲಿ ನೀವು ಒಂದು ವ್ಯಾಯಾಮ ಇಲ್ಲಿದೆ
ನಾವು ರಚನೆಗಳು ವಸ್ತುಗಳ ಅಂತಿಮಗೊಳಿಸಲು ಮೊದಲು.

247
00:12:28,110 --> 00:12:31,400
ಇಲ್ಲಿ ಕೋಡ್ ಗುಂಪನ್ನು, ಎಂದು ಇಲ್ಲಿದೆ
ವಿಶೇಷವಾಗಿ ಉತ್ತಮ ಶೈಲಿಯ,

248
00:12:31,400 --> 00:12:33,400
ನಾನು ಆ ತಡೆಯನ್ನು ಮಾಡಿಕೊಳ್ಳುವಿರಿ.

249
00:12:33,400 --> 00:12:36,660
ಇಲ್ಲಿ ಯಾವುದೇ ಕಾಮೆಂಟ್ಗಳನ್ನು ಇಲ್ಲ,
ಇದು ಬಹಳ ಕೆಟ್ಟ ರೂಪವಾಗಿದೆ.

250
00:12:36,660 --> 00:12:39,750
ಆದರೆ ನಾನು ಬಯಸುತ್ತೇನೆ ಏಕೆಂದರೆ ಮಾತ್ರ
ಪರದೆಯ ಮೇಲೆ ಎಲ್ಲವೂ ಹೊಂದಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಾಯಿತು.

251
00:12:39,750 --> 00:12:44,360
>> ಮೇಲ್ಭಾಗದಲ್ಲಿ, ನೀವು ನಾನು ಹೊಂದಿರುವ ನೋಡಬಹುದು
ಸೆಟ್ ಶ್ರೇಣಿಗೆ ಎರಡು ಕಾರ್ಯ ಘೋಷಣೆಗಳು

252
00:12:44,360 --> 00:12:45,820
ಮತ್ತು ಇಂಟ್ ಸೆಟ್.

253
00:12:45,820 --> 00:12:49,680
ಸೆಟ್ ಶ್ರೇಣಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಇದರ ಇನ್ಪುಟ್ ನಾಲ್ಕು ಪೂರ್ಣಾಂಕಗಳ.

254
00:12:49,680 --> 00:12:52,767
ಮತ್ತು ಸೆಟ್ ಇಂಟ್ ಸ್ಪಷ್ಟವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ
ಇದರ ಇನ್ಪುಟ್ ಎಂದು ಒಂದು ಪೂರ್ಣಾಂಕ.

255
00:12:52,767 --> 00:12:54,350
ಆದರೆ ಎರಡೂ ಒಂದು ಔಟ್ಪುಟ್ ಹೊಂದಿಲ್ಲ.

256
00:12:54,350 --> 00:12:57,689
ಔಟ್ಪುಟ್, ರಿಟರ್ನ್
ಪ್ರತಿ ಒಂದು ಶೂನ್ಯವನ್ನು ಆಫ್ ಟೈಪ್.

257
00:12:57,689 --> 00:12:59,480
ಮುಖ್ಯ, ನಾವು ಒಂದು
ಕೋಡ್ ಸಾಲುಗಳನ್ನು ಒಂದೆರಡು.

258
00:12:59,480 --> 00:13:02,730
ನಾವು ಪೂರ್ಣಾಂಕ ವೇರಿಯಬಲ್
ಒಂದು ಎಂದು ಮತ್ತು ಅದು ಮೌಲ್ಯ 10 ನಿಯೋಜಿಸಲು.

259
00:13:02,730 --> 00:13:07,080
ನಾವು ನಾಲ್ಕು ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು
ಬಿ ಕರೆದು ಅಂಶಗಳನ್ನು 0, 1 ನಿಯೋಜಿಸಲು,

260
00:13:07,080 --> 00:13:08,730
ಕ್ರಮವಾಗಿ 2 ಮತ್ತು 3,.

261
00:13:08,730 --> 00:13:12,190
ನಂತರ, ನಾವು ಹೊಂದಿಸಲು ಒಂದು ಕರೆ
ಇಂಟ್ ಮತ್ತು ಕರೆ ಶ್ರೇಣಿಯನ್ನು ಹೊಂದಿಸಲು.

262
00:13:12,190 --> 00:13:15,910
ಸೆಟ್ ಶ್ರೇಣಿಯನ್ನು ಮತ್ತು ಸೆಟ್ ವ್ಯಾಖ್ಯಾನಗಳು
ಇಂಟ್ ಕೆಳಭಾಗದಲ್ಲಿ ಕೆಳಗೆ ಕೆಳಗಿವೆ.

263
00:13:15,910 --> 00:13:17,640
>> ಆದ್ದರಿಂದ, ಮತ್ತೆ, ನಾನು ಪ್ರಶ್ನೆ ಕೇಳಿ.

264
00:13:17,640 --> 00:13:20,770
ಏನೆಂದು ಮುದ್ರಿತ ಮುಟ್ಟುತ್ತದೆ
ಇಲ್ಲಿ ಮುಖ್ಯ ಕೊನೆಯಲ್ಲಿ?

265
00:13:20,770 --> 00:13:23,020
ಒಂದು ಪ್ರಿಂಟ್ ಔಟ್ ಕೊಲ್ ಇಲ್ಲ. ನಾನು
ಎರಡು ಪೂರ್ಣಾಂಕಗಳ ಮುದ್ರಿಸುವ.

266
00:13:23,020 --> 00:13:28,010
ನಾನು ಒಂದು ವಿಷಯಗಳನ್ನು ಔಟ್ ಮುದ್ರಿಸುವ ನಾನು ಮತ್ತು
ಬಿ ಚದರ ಬ್ರಾಕೆಟ್ 0 ವಿಷಯಗಳನ್ನು.

267
00:13:28,010 --> 00:13:29,880
ಇಲ್ಲಿ ವೀಡಿಯೊ ವಿರಾಮ ಮತ್ತು ಒಂದು ನಿಮಿಷ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

268
00:13:29,880 --> 00:13:35,482
ನೀವು ಏನು ಈ ಲೆಕ್ಕಾಚಾರ ಮಾಡಬಹುದು
ಕಾರ್ಯ ಕೊನೆಯಲ್ಲಿ ಮುದ್ರಿಸಿ?

269
00:13:35,482 --> 00:13:38,190
ಆಶಾದಾಯಕವಾಗಿ, ನೀವು ನೆನಪಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ವೇಳೆ
ಮೌಲ್ಯ ಸಾಗುವ ನಡುವಿನ ವ್ಯತ್ಯಾಸ

270
00:13:38,190 --> 00:13:41,680
ಮತ್ತು ಉಲ್ಲೇಖ ಮೂಲಕ ಹಾದುಹೋಗುವ, ಈ
ಸಮಸ್ಯೆಯನ್ನು ನೀವು ಟೂ ಟ್ರಿಕಿ ಅಲ್ಲ.

271
00:13:41,680 --> 00:13:44,130
ಉತ್ತರವನ್ನು ಮತ್ತು ನೀವು
ಕಂಡು ಇದು.

272
00:13:44,130 --> 00:13:47,660
ನಿಮಗೆ ನಿಜವಾಗಿಯೂ ಖಚಿತವಾಗಿ ಇಲ್ಲದಿದ್ದರೆ
ಆ ಸಂದರ್ಭದಲ್ಲಿ ಏಕೆ, ಎರಡನೇ

273
00:13:47,660 --> 00:13:50,620
ಹಿಂತಿರುಗಿ, ನಾನು ಏನು ಪರಿಶೀಲಿಸಲು
ರಚನೆಗಳು ಹಾದುಹೋಗುವ ಬಗ್ಗೆ ಚರ್ಚೆ

274
00:13:50,620 --> 00:13:53,450
ಉಲ್ಲೇಖ ಮೂಲಕ ಹಾದು ವಿರುದ್ಧ
ಮೌಲ್ಯ ಇತರೆ ಅಂಶಗಳನ್ನು,

275
00:13:53,450 --> 00:13:56,680
ಮತ್ತು ಆಶಾದಾಯಕವಾಗಿ, ಮಾಡಿಕೊಳ್ಳುವಿರಿ
ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಅರ್ಥದಲ್ಲಿ.

276
00:13:56,680 --> 00:13:59,760
>> ನಾನು ಡೌಗ್ ಲಾಯ್ಡ್ ಮನುಷ್ಯ, ಮತ್ತು ಈ CS50 ಹೊಂದಿದೆ.

277
00:13:59,760 --> 00:14:01,467