1
00:00:00,000 --> 00:00:03,160
>> ಡೇವಿಡ್ ಜೆ MALAN: ನಾವು ಬರೆಯಲು ಬಯಸುವ ಭಾವಿಸೋಣ
ಎಲ್ಲರೂ ಕೇಳುವ ಒಂದು ಪ್ರೋಗ್ರಾಂ

2
00:00:03,160 --> 00:00:06,740
ಅವರ ವಯಸ್ಸು, ಮತ್ತು ನಂತರ ಮುದ್ರಿತ ಒಂದು ಕೊಠಡಿ
ಆ ಜನರು ಒಂದು ಎಷ್ಟು ಹಳೆಯ ಔಟ್

3
00:00:06,740 --> 00:00:07,520
ಹೀಗಾಗಿ ವರ್ಷದ?

4
00:00:07,520 --> 00:00:09,900
ಈಗ ಸ್ಪಷ್ಟವಾಗಿ ಈ ಅಂಕಗಣಿತದ
ಸಮಸ್ಯೆ ತಕ್ಕಮಟ್ಟಿಗೆ ಏರಲಿದೆ

5
00:00:09,900 --> 00:00:10,660
ನೇರ.

6
00:00:10,660 --> 00:00:14,090
ಆದರೆ ಕುತೂಹಲಕಾರಿ ಪ್ರಶ್ನೆ, ವೇಳೆ ನಾವು
ಮುಂಚಿತವಾಗಿ ಗೊತ್ತಿಲ್ಲ ಎಷ್ಟು ಜನರು

7
00:00:14,090 --> 00:00:16,790
ಈ ಕೋಣೆಯಲ್ಲಿ, ಹೇಗೆ ಹೋಗುವ
ನಾವು ಸಂಗ್ರಹಿಸುವ ಬಗ್ಗೆ ಹೋಗಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ

8
00:00:16,790 --> 00:00:17,980
ತಮ್ಮ ವಯಸ್ಸಿನ ಎಲ್ಲಾ?

9
00:00:17,980 --> 00:00:19,680
ಅಲ್ಲದೆ, ಅವಲೋಕಿಸೋಣ.

10
00:00:19,680 --> 00:00:22,760
>> ಮೊದಲ ಪ್ರೇರೇಪಿಸಿತು ಆರಂಭಿಸೋಣ
ಬಳಕೆದಾರ, ನಾನು, ಇಲ್ಲಿ ಮಾಡಿದ ಎಂದು

11
00:00:22,760 --> 00:00:26,410
ಬಳಸಿ ಕೋಣೆಯಲ್ಲಿ ಜನರ ಸಂಖ್ಯೆ
GetInt ಮತ್ತು ಸಲುವಾಗಿ ಒಂದು ಮಾಡಬೇಡಿ ಸಮಯದಲ್ಲಿ ಲೂಪ್

12
00:00:26,410 --> 00:00:28,220
ಒಂದು ಪೂರ್ಣಸಂಖ್ಯೆ n ಪಡೆಯಿರಿ.

13
00:00:28,220 --> 00:00:32,310
ನಾವು ಈಗ ಅಂತಹ ಪ್ರತಿ ಕೇಳಲು ಬಯಸುವ ಭಾವಿಸೋಣ
ತಮ್ಮ ವಯಸ್ಸಿಗೆ ಕೋಣೆಯಲ್ಲಿ ವ್ಯಕ್ತಿ.

14
00:00:32,310 --> 00:00:35,820
ಅಲ್ಲದೆ, ನನ್ನ ಸ್ವಭಾವವನ್ನು ಬಳಸಲು ಎಂದು ಒಂದು
ಎಂದು ಪ್ರೇರೇಪಿಸಿತು, ಆದರೆ ನಾನು ಲೂಪ್

15
00:00:35,820 --> 00:00:37,840
ಶೇಖರಿಸಲು ಸ್ಥಳವನ್ನು ಅಗತ್ಯವಿದೆ
ಆ ಜನರ ವಯಸ್ಸಿನ.

16
00:00:37,840 --> 00:00:40,760
ಮತ್ತು ನನ್ನ ಮೊದಲ ಪ್ರವೃತ್ತಿಗಳು ಇರುವುದಿಲ್ಲ
ಮೊದಲ ಒಂದು ವೇರಿಯಬಲ್ ಬಳಸಲು

17
00:00:40,760 --> 00:00:43,690
ವ್ಯಕ್ತಿಯ ವಯಸ್ಸು, ಮತ್ತೊಂದು ವ್ಯತ್ಯಾಸಗೊಳ್ಳುವ
ಎರಡನೇ ವ್ಯಕ್ತಿಯ ವಯಸ್ಸು,

18
00:00:43,690 --> 00:00:44,780
ರೀತಿಯ ಹಳಿಗಳ.

19
00:00:44,780 --> 00:00:46,230
ಇಂಟ್ ವಯಸ್ಸು -

20
00:00:46,230 --> 00:00:48,850
ಅಲ್ಲದೆ, 1 ಕರೆ ಅವಕಾಶ
ಮೊದಲ ವ್ಯಕ್ತಿ.

21
00:00:48,850 --> 00:00:51,480
ಎರಡನೇ ವ್ಯಕ್ತಿ ಇಂಟ್ ವಯಸ್ಸು 2.

22
00:00:51,480 --> 00:00:53,980
ಮೂರನೇ ವ್ಯಕ್ತಿ ಇಂಟ್ ವಯಸ್ಸು 3.

23
00:00:53,980 --> 00:00:56,750
>> ಆದರೆ ಒಂದು ನಿಮಿಷ ನಿರೀಕ್ಷಿಸಿ, ಈ ಬಹುಶಃ ಅಲ್ಲ
ಕೆಳಗೆ ಹೋಗಲು ಉತ್ತಮ ಮಾರ್ಗ.

24
00:00:56,750 --> 00:01:00,620
ನಾನು ಮುಂಚಿತವಾಗಿ ಗೊತ್ತಿಲ್ಲ ಏಕೆಂದರೆ
ಈ ಪ್ರೋಗ್ರಾಂ ಬರೆಯಲು ಮತ್ತು ಕಂಪೈಲ್ ಹೇಗೆ

25
00:01:00,620 --> 00:01:02,330
ಅನೇಕ ಬಳಕೆದಾರರು ಹೋಗುವ.

26
00:01:02,330 --> 00:01:06,590
ಮತ್ತು ಮೇಲಾಗಿ, ಅನೇಕ ಇಲ್ಲ ವೇಳೆ
100 ವ್ಯತ್ಯಾಸಗಳ ಘೋಷಿಸುವ 100 ಬಳಕೆದಾರರು,

27
00:01:06,590 --> 00:01:10,350
ಈ ಮಾಡುವುದಿಲ್ಲ ನಂತಹ ರೀತಿಯ ವಿಚಿತ್ರ ಹೆಸರಿನ
ಅತ್ಯುತ್ತಮ ವಿನ್ಯಾಸ ಆಗಲೇ.

28
00:01:10,350 --> 00:01:14,430
>> ಅಲ್ಲದೆ, Thankfully ಮತ್ತೊಂದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ
ಚರಮೌಲ್ಯದಬಗೆ ಎಂದು ಶ್ರೇಣಿಯನ್ನು ಎಂದು

29
00:01:14,430 --> 00:01:18,710
ನಮಗೆ ints ಯಾವುದೇ ಸಂಖ್ಯೆಯ ಶೇಖರಿಸಿಡಲು ಅನುವುಮಾಡಿಕೊಡುತ್ತದೆ
ಇದು ಒಳಗೆ, ನಾವು ಗೊತ್ತಿಲ್ಲ ಸಹ

30
00:01:18,710 --> 00:01:22,190
ನನ್ನ ಪ್ರೋಗ್ರಾಂ ಬರೆಯುವಾಗ ಎಷ್ಟು
ಇಂತಹ ints ನಾವು ಅಗತ್ಯವಿದೆ ನೀನು.

31
00:01:22,190 --> 00:01:25,970
ಆದ್ದರಿಂದ backtrack ಅವಕಾಶ ಮತ್ತು ಈ ಅಳಿಸಿ
ಬದಲಿಗೆ ಹಲವಾರು ints, ಮತ್ತು ಅದನ್ನು ಬದಲಾಯಿಸಲು

32
00:01:25,970 --> 00:01:29,620
ಒಂದು ವೇರಿಯೇಬಲ್ ಎಂಬ ಜೊತೆ,
, ವಯಸ್ಸಿನ, ಬಹುವಚನ ಹೇಳುತ್ತಾರೆ.

33
00:01:29,620 --> 00:01:33,420
ಆದರೆ ಹೆಚ್ಚಿನ ಈ ಸಾಲಿನಲ್ಲಿ ಸೂಚಿಸಲು ಅವಕಾಶ
ಚದರ ಆವರಣಗಳಲ್ಲಿ ಕೋಡ್ ಆ ನಾವು

34
00:01:33,420 --> 00:01:35,460
ಎನ್ ints ಬಯಸುವ.

35
00:01:35,460 --> 00:01:39,570
ಆದ್ದರಿಂದ, ನಾವು ಒಟ್ಟಾಗಿ ತಿನ್ನುವೆ
ವಯಸ್ಸಿನ ಈ ints ನೋಡಿ.

36
00:01:39,570 --> 00:01:43,490
>> ಈಗ ಕೇವಲ ಒಂದು ಕ್ಷಣದಲ್ಲಿ ನಾನು ಪಡೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ
ಈ ರಚನೆಯ ints ಪ್ರತಿಯೊಂದು

37
00:01:43,490 --> 00:01:47,270
ಇದೇ ಚೌಕಾಕಾರದ ಬ್ರಾಕೆಟ್ ಮೂಲಕ
ಸಂಕೇತನ, 0 ಪ್ರಾರಂಭವಾಗುವ.

38
00:01:47,270 --> 00:01:51,720
ಆದ್ದರಿಂದ ಒಂದು ಚಕ್ರಕ್ಕೆ ಈಗ ಮುಂದುವರೆಯಲು ಅವಕಾಶ
ತಮ್ಮ ವಯಸ್ಸಿನ ಬಳಕೆದಾರರನ್ನು ಕೇಳುತ್ತದೆ.

39
00:01:51,720 --> 00:01:54,780
ಇಂಟ್ ನಾನು 0 ಪಡೆಯಿರಿ.

40
00:01:54,780 --> 00:01:59,464
ನಾನು ಎನ್ ಕಡಿಮೆ, ಜನರ ಸಂಖ್ಯೆ
ಕೋಣೆಯಲ್ಲಿ, ನಾನು ಜೊತೆಗೆ ಹೆಚ್ಚು.

41
00:01:59,464 --> 00:02:06,610
>> ಈಗ ಈ ಲೂಪ್ ಒಳಗೆ, ಹೇಳಿ ನೋಡೋಣ
ವ್ಯಕ್ತಿ ಸಂಖ್ಯೆ, ಶೇಕಡಾ ನಾನು ಆಫ್ printf ವಯಸ್ಸು

42
00:02:06,610 --> 00:02:09,430
ಒಂದು ಪ್ಲೇಸ್ಹೋಲ್ಡರ್, ಅಲ್ಪವಿರಾಮ.

43
00:02:09,430 --> 00:02:13,210
ಈಗ, ಬದಲಿಗೆ ಎಣಿಸುವ ಆರಂಭಿಸಲು
ಪ್ರೋಗ್ರಾಮ್, ಅವಕಾಶ ತಂದೆಯ ನಲ್ಲಿ 0

44
00:02:13,210 --> 00:02:17,180
1 ಮೂಲಕ ಕನಿಷ್ಠ ಇನ್ಕ್ರಿಮೆಂಟ್ ನಾನು ಒಂದು ಸಾಮಾನ್ಯ
ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ವ್ಯಕ್ತಿ

45
00:02:17,180 --> 00:02:20,120
ಒಂದು ರೀತಿಯ ಎಣಿಕೆ ಹೊಂದಿಲ್ಲ
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿ ಇರಬಹುದು.

46
00:02:20,120 --> 00:02:26,130
ಈಗ ವಯಸ್ಸಿನ, ಬ್ರಾಕೆಟ್ ನಾನು, ತನ್ಮೂಲಕ ಮಾಡೋಣ
ಎಂದು ಸೂಚಿಸುವ I-ನೇ ವಯಸ್ಸಿನಲ್ಲಿ ನಮ್ಮ

47
00:02:26,130 --> 00:02:31,480
ವಯಸ್ಸಿನ ರಚನೆಯ ಕಾಣುವುದು ಇದೆ
GetInt ಮರಳುವ ಮೌಲ್ಯವನ್ನು.

48
00:02:31,480 --> 00:02:37,800
>> ಈಗ ಈ ಲೂಪ್ ಕೆಳಗೆ, ನ ಮುಂದುವರೆಯಲು ಅವಕಾಶ
ಕೆಲವು ಕಳೆದಂತೆ ತಿಳಿಯುವುದು.

49
00:02:37,800 --> 00:02:41,690
ಮತ್ತು ಈಗ ಮತ್ತೊಂದು ಚಕ್ರಕ್ಕೆ ಮುಂದುವರೆಯಲು ಅವಕಾಶ
ವಾಸ್ತವವಾಗಿ ಕೋಣೆಯಲ್ಲಿ ಎಲ್ಲರೂ ವಯಸ್ಸಿನ

50
00:02:41,690 --> 00:02:42,800
ಒಂದು ವರ್ಷ.

51
00:02:42,800 --> 00:02:48,110
ಆದ್ದರಿಂದ ಮತ್ತೆ, ನಾನು 0 ಪಡೆಯಲು ಇಂಟ್, ನಾನು ಕಡಿಮೆ
ಎನ್ ಹೆಚ್ಚು, ಜನರ ಸಂಖ್ಯೆ

52
00:02:48,110 --> 00:02:49,680
ಕೊಠಡಿ, ನಾನು ಜೊತೆಗೆ ಹೆಚ್ಚು.

53
00:02:49,680 --> 00:02:57,210
>> ಈಗ ಈ ಲೂಪ್ ಒಳಗೆ, ಹೇಳಿ ನೋಡೋಣ
ಈಗ ವ್ಯಕ್ತಿ ಸಂಖ್ಯೆ ಒಂದು ವರ್ಷ, printf

54
00:02:57,210 --> 00:03:00,990
ಶೇಕಡಾ ನಾನು ಒಂದು ಪ್ಲೇಸ್ಹೋಲ್ಡರ್, ತಿನ್ನುವೆ
ಎಂದು, ಶೇಕಡಾ ನಾನು ಇನ್ನೊಂದು

55
00:03:00,990 --> 00:03:03,210
ವರ್ಷ ಪ್ಲೇಸ್ಹೋಲ್ಡರ್,.

56
00:03:03,210 --> 00:03:07,230
ತದನಂತರ ಆ ಪ್ಲಗ್
placeholders, ಮೊದಲ ನಾನು ಹೇಳಲು ಅವಕಾಶ ಜೊತೆಗೆ

57
00:03:07,230 --> 00:03:11,220
1, ಆದ್ದರಿಂದ ಮತ್ತೆ ನಾವು ಎಣಿಸುವ ಆರಂಭಿಸಲು
1 ರಿಂದ ಬಳಕೆದಾರ.

58
00:03:11,220 --> 00:03:18,630
ತದನಂತರ ಆ ವ್ಯಕ್ತಿಯ ವಯಸ್ಸು ಪ್ಲಗ್ ಅವಕಾಶ
ತನ್ಮೂಲಕ ವಯಸ್ಸಿನ ಬ್ರಾಕೆಟ್ ನಾನು ಜೊತೆಗೆ 1, ಮಾಹಿತಿ

59
00:03:18,630 --> 00:03:23,740
I-ನೇ ವಯಸ್ಸಿನಲ್ಲಿ ಪಡೆಯಲು ಹೋಗಿ ಸೂಚಿಸುವ ನಮ್ಮ
ವಯಸ್ಸಿನ ರಚನೆಯ ನಂತರ ಇದು 1 ಸೇರಿಸಿ, ಮತ್ತು

60
00:03:23,740 --> 00:03:28,370
ನಮ್ಮ ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ ಒಳಗೆ ಎಂದು ಮೊತ್ತ ಸೇರಿಸಲು,
ಹತ್ತಿರದ ಆವರಣ, ಅಲ್ಪವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ.

61
00:03:28,370 --> 00:03:33,280
>> ನ ಈಗ ಈ ಪ್ರೋಗ್ರಾಂ ಕಂಪೈಲ್ ಲೆಟ್
ವಯಸ್ಸಿನ, ಮತ್ತು ನ ಚುಕ್ಕೆ ಚಲಾಯಿಸಲು ಅವಕಾಶ

62
00:03:33,280 --> 00:03:34,990
ವಯಸ್ಸಿನ ಕಡಿದು.

63
00:03:34,990 --> 00:03:38,770
ಮತ್ತು ಕೇವಲ ಮೂರು ಇವೆ ಎಂದು ಊಹಿಸಿಕೊಳ್ಳಿ
ಕೋಣೆಯಲ್ಲಿ ಜನರು, ಮತ್ತು ಯಾರಾದರೂ 18,

64
00:03:38,770 --> 00:03:40,700
ಯಾರಾದರೂ 19, ಯಾರಾದರೂ 20 ಆಗಿದೆ.

65
00:03:40,700 --> 00:03:45,350
ಅಲ್ಲದೆ, ಒಂದು ವರ್ಷದ, ಪ್ರತಿ ಆ ಜನರಾಗಿದ್ದರು
, 19, 20, ಮತ್ತು 21 ಏರಲಿದೆ

66
00:03:45,350 --> 00:03:46,600
ಕ್ರಮವಾಗಿ.

67
00:03:46,600 --> 00:03:48,948