1
00:00:00,000 --> 00:00:03,160
>> డేవిడ్ J. మలన్: మేము రాయాలనుకుంటున్నాను ఒకవేళ
ప్రతి ఒక్కరూ అడిగే ఒక కార్యక్రమం

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
Int వయస్సు -

20
00:00:46,230 --> 00:00:48,850
బాగా, యొక్క కోసం 1 కాల్ తెలియజేయండి
మొదటి వ్యక్తి.

21
00:00:48,850 --> 00:00:51,480
రెండవ వ్యక్తి కోసం Int వయస్సు 2.

22
00:00:51,480 --> 00:00:53,980
మూడవ వ్యక్తి కోసం Int వయస్సు 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
>> బాగా, కృతజ్ఞతగా మరొక ఉంది
వేరియబుల్ రకం అని వ్యూహం అని

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
కాబట్టి యొక్క చలించు వీలు మరియు ఈ తొలగించడానికి
బదులుగా అనేక 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
n 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
Int కోసం నేను 0 పొందుటకు.

40
00:01:54,780 --> 00:01:59,464
నేను N కంటే తక్కువ, ప్రజల సంఖ్య
గదిలో, నేను ప్లస్ ప్లస్.

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-th వయస్సు మా

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 Int పొందండి కోసం, నేను తక్కువ ఉంది
N కంటే, ప్రజల సంఖ్య

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-th వయస్సు పొందుటకు గో పేర్కొనడం మా
వయసుల శ్రేణి, దానికి 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