1
00:00:00,000 --> 00:00:00,493

2
00:00:00,493 --> 00:00:09,860
>> [సంగీతాన్ని]

3
00:00:09,860 --> 00:00:13,520
>> ZAMYLA చాన్: మీరు బదులుగా పొందుతాయి
$ 10 మిలియన్ ప్రస్తుతం లేదా స్వీకరించేందుకు

4
00:00:13,520 --> 00:00:17,460
పెన్నీలు నెల ప్రతి రోజు, పేరు
ప్రతి తదుపరి రోజు, మీరు అందుకుంటారు

5
00:00:17,460 --> 00:00:21,280
మీరు నాణేలు మొత్తం రెట్టింపు
ముందు రోజు అందుకుంది?

6
00:00:21,280 --> 00:00:24,010
పెన్నీలు లో, మేము చేయబోతున్నామని
నిరూపించడానికి ఎందుకు మీరు తప్పక

7
00:00:24,010 --> 00:00:27,000
ఖచ్చితంగా పెన్నీలు పడుతుంది.

8
00:00:27,000 --> 00:00:29,130
- Pennies.c-మీ ఉద్యోగం రాసే

9
00:00:29,130 --> 00:00:33,330
మొదటిది ఎంత యూజర్ అడిగే కార్యక్రమం
అక్కడ అనేక రోజుల నెలలో మరియు

10
00:00:33,330 --> 00:00:38,780
తరువాత వినియోగదారు ఎన్ని నాణేలు అడుగుతుంది
మొదటి రోజు అందుకుంటారు.

11
00:00:38,780 --> 00:00:41,780
ప్రోగ్రామ్ తరువాత లెక్కించేందుకు ఉండాలి
యూజర్ ఉంటుంది మొత్తం

12
00:00:41,780 --> 00:00:46,530
చివరిలో సేకరించారు
నెల మరియు ప్రదర్శించవచ్చు.

13
00:00:46,530 --> 00:00:49,670
>> మేము ఈ కార్యక్రమం విచ్ఛిన్నం చేయవచ్చు
విధులను జంట లోకి.

14
00:00:49,670 --> 00:00:52,830
మేము అడుగుతుంది చేయాలి
బహుళ యూజర్ ఇన్పుట్లను -

15
00:00:52,830 --> 00:00:55,510
రోజుల మరియు నెలల, మరియు పెన్నీలు
మొదటి రోజు.

16
00:00:55,510 --> 00:00:59,390
మేము ట్రాక్ అవసరం ఎంత డబ్బు
యూజర్ ప్రతి ఉంది మరియు ఇది అప్డేట్

17
00:00:59,390 --> 00:01:03,060
రోజు, మొత్తం ఆఫ్ రెట్టింపు
వారు స్వీకరించిన పెన్నీలు.

18
00:01:03,060 --> 00:01:06,710
చివరకు, మేము ప్రింట్ వారి
డాలర్లలో చివరి మొత్తం.

19
00:01:06,710 --> 00:01:08,570
>> మొదటి TACKLE వినియోగదారు ఇన్పుట్ యొక్క లెట్.

20
00:01:08,570 --> 00:01:11,560
నేను, apples.c తెరవటానికి వెళుతున్నాను
చేపట్టే చిన్న కార్యక్రమం

21
00:01:11,560 --> 00:01:13,840
ఇన్పుట్లను మరియు నిర్గమనాలతో.

22
00:01:13,840 --> 00:01:17,310
ఇక్కడ ఎగువన, నేను కొన్ని చేర్చాను
- నేను అవసరమైన లైబ్రరీలను

23
00:01:17,310 --> 00:01:20,450
CS50 లైబ్రరీ మరియు ఒక ప్రామాణిక
I / O లైబ్రరీ.

24
00:01:20,450 --> 00:01:24,310
నేను ఉపయోగించి ఒక ప్రాంప్ట్ ప్రింట్
నుండి printf ఫంక్షన్

25
00:01:24,310 --> 00:01:25,660
ప్రామాణిక I / O లైబ్రరీ.

26
00:01:25,660 --> 00:01:29,740
కానీ వినియోగదారు ప్రాంప్ట్ అసలు
ఈ తదుపరి లైన్ లో జరుగుతుంది

27
00:01:29,740 --> 00:01:33,650
CS50 లైబ్రరీ లో GetInt ఫంక్షన్.

28
00:01:33,650 --> 00:01:38,300
>> GetInt వినియోగదారు నుండి ఇన్పుట్ మరియు సేకరిస్తుంది
ఇన్పుట్ పూర్ణాంకం నిర్ధారిస్తుంది.

29
00:01:38,300 --> 00:01:45,160
నేను పూర్ణాంక లోకి యూజర్ యొక్క ఇన్పుట్ నిల్వ
నేను నుండి 1 తగ్గించు, ఆపై

30
00:01:45,160 --> 00:01:47,610
i ఉంటే కొత్త విలువ అవ్ట్ ప్రింట్.

31
00:01:47,610 --> 00:01:53,050
ఉపయోగించి apples.c కంపైల్ తరువాత
కమాండ్ "ఆపిల్ల తయారు," నేను ఒక కలిగి

32
00:01:53,050 --> 00:01:55,770
ఎక్జిక్యూటబుల్ ఫైల్ ఆపిల్ల.

33
00:01:55,770 --> 00:01:58,760
నేను ఇన్పుట్ 1, ఆ చేస్తాను నడుస్తున్న.

34
00:01:58,760 --> 00:02:02,600
కార్యక్రమం నాకు చెబుతాడు
నేను వదిలి 0 ఆపిల్.

35
00:02:02,600 --> 00:02:05,480
అందువలన ఊహించిన పనిచేసింది.

36
00:02:05,480 --> 00:02:09,740
>> సో యొక్క మళ్లీ ఈ అమలు తెలపండి
ప్రతికూల మరియు ఇన్పుట్ 1.

37
00:02:09,740 --> 00:02:13,950
ఇప్పుడు, ఆపిల్ల యొక్క ప్రతికూల మొత్తం కలిగి
నిజంగా అర్ధవంతం, కానీ లేదు

38
00:02:13,950 --> 00:02:18,370
ప్రతికూల ఎందుకంటే కార్యక్రమం, ఇది అంగీకరిస్తుంది
1, బాగా, అది ఒక పూర్ణ సంఖ్య.

39
00:02:18,370 --> 00:02:22,740
మరియు ఇప్పుడు కార్యక్రమం లేదా రాక్షసుడు
కార్యక్రమం ప్రతికూల తింటున్న లోపల

40
00:02:22,740 --> 00:02:26,250
ఆపిల్, మరియు ఇప్పుడు నేను
ప్రతికూల 2 ఆపిల్ల.

41
00:02:26,250 --> 00:02:28,610
అవును, తద్వారా ఒక పాఠం ఉంది -

42
00:02:28,610 --> 00:02:32,965
అయినప్పటికీ GetInt ఫంక్షన్ మరియు
సంబంధిత GetFlow మాదిరిగా పనిచేస్తుంది, లేదా

43
00:02:32,965 --> 00:02:38,100
పొందండి కుడి డేటా రకం GetString, మీరు
ఇన్పుట్ చేస్తుంది నిర్ధారించుకోండి ఉంటుంది

44
00:02:38,100 --> 00:02:41,430
మీ ప్రోగ్రామ్ భావనను.

45
00:02:41,430 --> 00:02:45,500
>> పెన్నీలు లో, ఇది కేవలం ఒక ప్రాంప్ట్ చేయరు
పూర్ణాంకం కోసం, మీరు తయారు చెయ్యాలి

46
00:02:45,500 --> 00:02:49,550
ఖచ్చితంగా వినియోగదారు ఇన్పుట్లను పూర్ణాంకం ఆ
ఆ సందర్భంలో ఇచ్చిన అర్ధవంతం.

47
00:02:49,550 --> 00:02:55,690
నెల మాత్రమే, 28 ఉండవచ్చు
29, 30, లేదా 31 రోజుల.

48
00:02:55,690 --> 00:02:59,160
మేము నిరంతరం డిమాండ్ కావలసిన
ఒక చెల్లుబాటు అయ్యే పూర్ణాంక.

49
00:02:59,160 --> 00:03:03,240
వారు ఇన్పుట్ మా యొక్క పూర్ణాంకం బయట ఉంటే
అంగీకరించిన హద్దులు, మేము వాటిని ప్రాంప్ట్

50
00:03:03,240 --> 00:03:07,190
మళ్లీ మళ్లీ, వరకు
మాకు ఒక చెల్లుబాటు అయ్యే పూర్ణాంక ఇవ్వాలని.

51
00:03:07,190 --> 00:03:10,070
>> "వరకు రిపీట్" గుర్తు
స్క్రాచ్ లో బ్లాక్?

52
00:03:10,070 --> 00:03:13,070
మీరు ఇదే నిర్మాణం చేయవచ్చు
సి లో ఒక "అయితే" లూప్ ఉపయోగించి

53
00:03:13,070 --> 00:03:14,830
లేదా "అలా-అయితే" లూప్.

54
00:03:14,830 --> 00:03:18,280
అయితే లూప్ నిర్మాణం ఒక పరిస్థితి ఉంది
కోసం కలుసుకున్నారు తప్పక

55
00:03:18,280 --> 00:03:20,160
అమలు లూప్ యొక్క శరీరం.

56
00:03:20,160 --> 00:03:23,080
>> ఈ, ఒక చిన్న పోలి చూడండి ఉండాలి
పరిస్థితి వలె ఎందుకంటే

57
00:03:23,080 --> 00:03:25,970
కోణాలతో మొదటి బ్లాక్స్
మరియు బ్రాకెట్లలో లోకి వెళ్ళిపోతుంది

58
00:03:25,970 --> 00:03:27,950
"అయితే" లూప్ యొక్క.

59
00:03:27,950 --> 00:03:30,600
తద్వారా పరిస్థితి అని తనిఖీ చేస్తుంది
పూర్ణాంక లోపల ఉంది

60
00:03:30,600 --> 00:03:32,680
తగిన హద్దులు.

61
00:03:32,680 --> 00:03:36,620
మీరు పూర్ణాంక ఉపయోగించి GetInt ప్రేరేపిస్తుంది
ఆపై మీ "అయితే" అమలు

62
00:03:36,620 --> 00:03:41,030
లూప్, పునరావృతమైన ప్రాంప్ట్ మరియు ముద్రణ
సూచనలు, అయితే ఇన్పుట్

63
00:03:41,030 --> 00:03:43,470
చెల్లదు.

64
00:03:43,470 --> 00:03:47,610
>> సరైన యూజర్ ఇన్పుట్ నిర్ధారించడానికి మరో మార్గం
ఒక "మీరు అయితే" లూప్ ఉపయోగించి

65
00:03:47,610 --> 00:03:50,400
ఇది ఒక సమయంలో లూప్ చాలా పోలి ఉంటుంది.

66
00:03:50,400 --> 00:03:54,950
"అలా-అయితే" లూప్ కోడ్ అమలు
శరీరం వాటిని ఆపై తనిఖీలను లోపల

67
00:03:54,950 --> 00:03:57,150
పరిస్థితి ఏర్పడితే లేదా అని.

68
00:03:57,150 --> 00:04:00,590
ఈ, వినియోగదారు ఇన్పుట్ తీసుకోవటానికి ఉపయోగపడుతుంది
మీరు అవసరం తెలుసు ఎందుకంటే

69
00:04:00,590 --> 00:04:02,980
కనీసం ఒకసారి వాటిని ఫలితానికి.

70
00:04:02,980 --> 00:04:07,200
పరిస్థితి హజరు కాకపోతే, కార్యక్రమం
తరువాత లైన్ అమలు అవుతుంది

71
00:04:07,200 --> 00:04:08,530
మీ "అలా-అయితే" లూప్.

72
00:04:08,530 --> 00:04:13,230
పరిస్థితి అయితే ఏర్పడితే,
లూప్ పునరావృతం

73
00:04:13,230 --> 00:04:17,490
>> యూజర్ నిర్ధారించడంలో ఒక "అలా-అయితే" లూప్
ఇన్పుట్ ఈ వంటి ఏదో కనిపిస్తాయని.

74
00:04:17,490 --> 00:04:24,530
నేను ఒక వేరియబుల్ n, GetInt ప్రకటించి,
n చెల్లుబాటు అయ్యే వరకు అప్పుడు పునరావృతం.

75
00:04:24,530 --> 00:04:28,040
మరియు ఈ ప్రక్రియ, నేను వివరించారు, ఉపయోగించి జరిగినది
పూర్ణాంక-డేటా రకం, ఇది

76
00:04:28,040 --> 00:04:29,820
మీరు నెల రోజులు ఉపయోగిస్తాము.

77
00:04:29,820 --> 00:04:33,560
కానీ మనకు తెలుసు, నాణేలు సంఖ్య
క్రమంలో కాబట్టి, త్వరగా పైల్ ఉంటుంది

78
00:04:33,560 --> 00:04:39,160
పెద్ద సంఖ్యలను నిల్వ, డేటా రకం ఉపయోగించడానికి
LongLong, కానీ అదే గుర్తు

79
00:04:39,160 --> 00:04:42,590
ధ్రువీకరణ సూత్రం వర్తిస్తుంది.

80
00:04:42,590 --> 00:04:47,070
>> అద్భుతం, కాబట్టి ఒకసారి మేము రెండు చెల్లుబాటులో కలిగి
యూజర్ ఇన్పుట్లను -

81
00:04:47,070 --> 00:04:49,530
నెలలో రోజుల మరియు పెన్నీలు
మొదటి రోజు -

82
00:04:49,530 --> 00:04:52,870
మేము తదుపరి లోకి వెళ్ళవచ్చు
కార్యక్రమంలో భాగంగా.

83
00:04:52,870 --> 00:04:56,680
మొదటి రోజు, వినియోగదారు మొదలవుతుంది
ప్రత్యేక అయితే అనేక నాణేలు

84
00:04:56,680 --> 00:05:00,370
మరియు నాణేలు మొత్తం వారు
తదుపరి రోజు అందుకుంటారు రెట్టింపు.

85
00:05:00,370 --> 00:05:03,130
కనుక ఇది ట్రాక్ అర్ధమే
ఈ రెండు మొత్తంలో -

86
00:05:03,130 --> 00:05:08,890
యూజర్ ఉంది మరియు ఎలా ఎంత డబ్బు
అనేక నాణేలు వారు ఇవ్వబడుతుంది.

87
00:05:08,890 --> 00:05:13,760
>> ఇప్పుడు, 28 31 రోజులు ఏదో చేయడం
పునరావృత ఉంది, కాబట్టి యొక్క ఒక "కోసం" ఉపయోగించడానికి అనుమతిస్తున్నట్లు

88
00:05:13,760 --> 00:05:18,220
లో రోజుల పాటు iterate లూప్
నెల, మొత్తం మరియు పెన్నీ నవీకరించుటకు

89
00:05:18,220 --> 00:05:21,010
ప్రతి సమయం జోస్యం.

90
00:05:21,010 --> 00:05:23,550
లూప్ సింటాక్స్ కలిగి "కోసం"
కింది -

91
00:05:23,550 --> 00:05:27,510
ఒక ప్రారంభ, ఒక పరిస్థితి,
మరియు ఒక నవీకరణ.

92
00:05:27,510 --> 00:05:29,590
మీ "కోసం" లూప్ ప్రారంభించడం ఉంటుంది
ఒక వేరియబుల్, అది

93
00:05:29,590 --> 00:05:31,380
మొదటి లూప్ ప్రవేశిస్తుంది.

94
00:05:31,380 --> 00:05:34,860
పరిస్థితి ఏర్పడితే, శరీరం
లూప్ యొక్క అమలు అవుతుంది.

95
00:05:34,860 --> 00:05:36,860
తరువాత, నవీకరణ అమలు అవుతుంది.

96
00:05:36,860 --> 00:05:40,900
పరిస్థితి ఇప్పటికీ ఏర్పడితే,
లూప్ అమలు మరియు అప్ డేట్ చేస్తుంది

97
00:05:40,900 --> 00:05:45,820
కాలం మీ పరిస్థితి, పునరావృతం
నిజమైన కు అంచనాలు.

98
00:05:45,820 --> 00:05:51,080
>> ఇక్కడ ఒక విభజిస్తుంది ఒక "కోసం" లూప్ వార్తలు
2 10 సార్లు మొత్తం ద్వారా పూర్ణాంక p.

99
00:05:51,080 --> 00:05:55,380
నేను పూర్ణాంక p ప్రకటించింది ఎలా గమనించండి
నా "కోసం" లూప్ వెలుపల, తద్వారా

100
00:05:55,380 --> 00:05:59,850
పూర్ణాంక పొందవచ్చు
"కోసం" లూప్ బయట.

101
00:05:59,850 --> 00:06:03,620
నెల ఆమోదించింది తర్వాత, సమయం
యూజర్ చెప్పడానికి ఎంత డబ్బు

102
00:06:03,620 --> 00:06:04,790
వారు సంపాదించిన చేసిన.

103
00:06:04,790 --> 00:06:08,740
స్పెక్ ప్రతి, మీరు యూజర్ చెప్పడానికి అవసరం
ఎన్ని డాలర్లు, కాదు ఎన్ని

104
00:06:08,740 --> 00:06:10,780
పెన్నీలు, వారు కలిగి.

105
00:06:10,780 --> 00:06:14,620
కానీ ఇప్పటివరకు, మీరు ట్రాక్ ఉంచింది చేసిన
మొత్తం మరియు LongLongs ఉపయోగించి పెన్నీలు,

106
00:06:14,620 --> 00:06:16,640
పూర్ణ సంఖ్యలు చెప్పవచ్చు.

107
00:06:16,640 --> 00:06:20,560
>> $ 1 కు 100 పెన్నీలు కాబట్టి, అక్కడ తప్ప
పెన్నీలు సంఖ్య ఒక

108
00:06:20,560 --> 00:06:24,860
100 బహుళ, మీరు చెయ్యాలి
దశాంశ స్థలాలు సూచిస్తాయి.

109
00:06:24,860 --> 00:06:28,060
రెట్టింపు autotype అనుమతిస్తుంది
మీరు దీన్ని.

110
00:06:28,060 --> 00:06:32,790
సో ఎలా మేము ప్రాతినిధ్యం మార్చడంలో లేదు
డాలర్లకు పెన్నీలు?

111
00:06:32,790 --> 00:06:35,330
>> యొక్క పరిశీలించి లెట్ pi.c.

112
00:06:35,330 --> 00:06:41,690
ఈ కార్యక్రమం ఒక LongLong big_pi మరియు పడుతుంది
100,000 ద్వారా విభజిస్తుంది, మరియు ముద్రిస్తుంది

113
00:06:41,690 --> 00:06:44,270
ఐదు దశాంశ స్థానాల వరకు ఫలితంగా.

114
00:06:44,270 --> 00:06:48,560
మేము నాలుగు దశాంశ ప్రదర్శించడానికి కోరుకుంటే
స్థలాలు, అప్పుడు మేము కేవలం ఈ భర్తీ చేయవచ్చు

115
00:06:48,560 --> 00:06:49,760
ఇక్కడ సంఖ్య.

116
00:06:49,760 --> 00:06:58,370
సో యొక్క సేవ్ pi కంపైల్ మరియు తెలపండి
అప్పుడు, ఫలితంగా చూసిన మేము

117
00:06:58,370 --> 00:07:02,240
3,1415 అని ఆశించే -

118
00:07:02,240 --> 00:07:04,540
pi మొదటి ఐదు అంకెలు.

119
00:07:04,540 --> 00:07:06,300
>> ఇది అయితే కాదు.

120
00:07:06,300 --> 00:07:07,390
మరియు ఎందుకు?

121
00:07:07,390 --> 00:07:11,920
బాగా, big_pi, ఒక LongLong ఎందుకంటే
మొత్తం సంఖ్య, ఇది ఇది లేదు

122
00:07:11,920 --> 00:07:13,740
దశాంశాలు ట్రాక్.

123
00:07:13,740 --> 00:07:16,850
నేను అవసరం మార్పు
తయారు విభాగం ఉంది.

124
00:07:16,850 --> 00:07:23,300
నేను ముందు ఇక్కడ ఒక డబుల్ నటించాడు అవసరం
డబుల్స్ ఉంచేందుకు ఎందుకంటే, విభజన

125
00:07:23,300 --> 00:07:25,260
దశాంశ స్థానాల ట్రాక్.

126
00:07:25,260 --> 00:07:28,080
మరియు నేను ఒక కొత్త లైనును వెళుతున్న
ఇక్కడ మంచి ఫార్మాటింగ్ కోసం.

127
00:07:28,080 --> 00:07:33,090

128
00:07:33,090 --> 00:07:34,230
>> మరియు ఇక్కడ మేము కలిగి -

129
00:07:34,230 --> 00:07:37,660
3,1416.

130
00:07:37,660 --> 00:07:43,520
మీరు 3.1416 ముద్రిస్తుంది ఆ గమనిస్తారు
బదులుగా 3,1415 నాటికి అంచనా.

131
00:07:43,520 --> 00:07:47,550
సమయంలో ఎందుకంటే రౌండ్లు ఆ
డివిజన్ ప్రక్రియ, కేవలం వ్యతిరేకంగా

132
00:07:47,550 --> 00:07:50,490
విలువ తగ్గిస్తోంది.

133
00:07:50,490 --> 00:07:53,710
ఇప్పుడు మీరు ముద్రించడానికి ఉండాలి
పూర్తి ఇది సరిగ్గా చివరి మొత్తం,

134
00:07:53,710 --> 00:07:54,870
కార్యక్రమం.

135
00:07:54,870 --> 00:07:55,930
>> అభినందనలు.

136
00:07:55,930 --> 00:07:57,340
నా పేరు Zamyla ఉంది.

137
00:07:57,340 --> 00:07:58,720
మరియు ఈ నాణేలు ఉంది.

138
00:07:58,720 --> 00:08:05,589
>> [సంగీతాన్ని]