>> [సంగీతాన్ని]
>> ZAMYLA చాన్: మీరు బదులుగా పొందుతాయి $ 10 మిలియన్ ప్రస్తుతం లేదా స్వీకరించేందుకు
పెన్నీలు నెల ప్రతి రోజు, పేరు ప్రతి తదుపరి రోజు, మీరు అందుకుంటారు
మీరు నాణేలు మొత్తం రెట్టింపు ముందు రోజు అందుకుంది?
పెన్నీలు లో, మేము చేయబోతున్నామని నిరూపించడానికి ఎందుకు మీరు తప్పక
ఖచ్చితంగా పెన్నీలు పడుతుంది.
- Pennies.c-మీ ఉద్యోగం రాసే
మొదటిది ఎంత యూజర్ అడిగే కార్యక్రమం అక్కడ అనేక రోజుల నెలలో మరియు
తరువాత వినియోగదారు ఎన్ని నాణేలు అడుగుతుంది మొదటి రోజు అందుకుంటారు.
ప్రోగ్రామ్ తరువాత లెక్కించేందుకు ఉండాలి యూజర్ ఉంటుంది మొత్తం
చివరిలో సేకరించారు నెల మరియు ప్రదర్శించవచ్చు.
>> మేము ఈ కార్యక్రమం విచ్ఛిన్నం చేయవచ్చు విధులను జంట లోకి.
మేము అడుగుతుంది చేయాలి బహుళ యూజర్ ఇన్పుట్లను -
రోజుల మరియు నెలల, మరియు పెన్నీలు మొదటి రోజు.
మేము ట్రాక్ అవసరం ఎంత డబ్బు యూజర్ ప్రతి ఉంది మరియు ఇది అప్డేట్
రోజు, మొత్తం ఆఫ్ రెట్టింపు వారు స్వీకరించిన పెన్నీలు.
చివరకు, మేము ప్రింట్ వారి డాలర్లలో చివరి మొత్తం.
>> మొదటి TACKLE వినియోగదారు ఇన్పుట్ యొక్క లెట్.
నేను, apples.c తెరవటానికి వెళుతున్నాను చేపట్టే చిన్న కార్యక్రమం
ఇన్పుట్లను మరియు నిర్గమనాలతో.
ఇక్కడ ఎగువన, నేను కొన్ని చేర్చాను - నేను అవసరమైన లైబ్రరీలను
CS50 లైబ్రరీ మరియు ఒక ప్రామాణిక I / O లైబ్రరీ.
నేను ఉపయోగించి ఒక ప్రాంప్ట్ ప్రింట్ నుండి printf ఫంక్షన్
ప్రామాణిక I / O లైబ్రరీ.
కానీ వినియోగదారు ప్రాంప్ట్ అసలు ఈ తదుపరి లైన్ లో జరుగుతుంది
CS50 లైబ్రరీ లో GetInt ఫంక్షన్.
>> GetInt వినియోగదారు నుండి ఇన్పుట్ మరియు సేకరిస్తుంది ఇన్పుట్ పూర్ణాంకం నిర్ధారిస్తుంది.
నేను పూర్ణాంక లోకి యూజర్ యొక్క ఇన్పుట్ నిల్వ నేను నుండి 1 తగ్గించు, ఆపై
i ఉంటే కొత్త విలువ అవ్ట్ ప్రింట్.
ఉపయోగించి apples.c కంపైల్ తరువాత కమాండ్ "ఆపిల్ల తయారు," నేను ఒక కలిగి
ఎక్జిక్యూటబుల్ ఫైల్ ఆపిల్ల.
నేను ఇన్పుట్ 1, ఆ చేస్తాను నడుస్తున్న.
కార్యక్రమం నాకు చెబుతాడు నేను వదిలి 0 ఆపిల్.
అందువలన ఊహించిన పనిచేసింది.
>> సో యొక్క మళ్లీ ఈ అమలు తెలపండి ప్రతికూల మరియు ఇన్పుట్ 1.
ఇప్పుడు, ఆపిల్ల యొక్క ప్రతికూల మొత్తం కలిగి నిజంగా అర్ధవంతం, కానీ లేదు
ప్రతికూల ఎందుకంటే కార్యక్రమం, ఇది అంగీకరిస్తుంది 1, బాగా, అది ఒక పూర్ణ సంఖ్య.
మరియు ఇప్పుడు కార్యక్రమం లేదా రాక్షసుడు కార్యక్రమం ప్రతికూల తింటున్న లోపల
ఆపిల్, మరియు ఇప్పుడు నేను ప్రతికూల 2 ఆపిల్ల.
అవును, తద్వారా ఒక పాఠం ఉంది -
అయినప్పటికీ GetInt ఫంక్షన్ మరియు సంబంధిత GetFlow మాదిరిగా పనిచేస్తుంది, లేదా
పొందండి కుడి డేటా రకం GetString, మీరు ఇన్పుట్ చేస్తుంది నిర్ధారించుకోండి ఉంటుంది
మీ ప్రోగ్రామ్ భావనను.
>> పెన్నీలు లో, ఇది కేవలం ఒక ప్రాంప్ట్ చేయరు పూర్ణాంకం కోసం, మీరు తయారు చెయ్యాలి
ఖచ్చితంగా వినియోగదారు ఇన్పుట్లను పూర్ణాంకం ఆ ఆ సందర్భంలో ఇచ్చిన అర్ధవంతం.
నెల మాత్రమే, 28 ఉండవచ్చు 29, 30, లేదా 31 రోజుల.
మేము నిరంతరం డిమాండ్ కావలసిన ఒక చెల్లుబాటు అయ్యే పూర్ణాంక.
వారు ఇన్పుట్ మా యొక్క పూర్ణాంకం బయట ఉంటే అంగీకరించిన హద్దులు, మేము వాటిని ప్రాంప్ట్
మళ్లీ మళ్లీ, వరకు మాకు ఒక చెల్లుబాటు అయ్యే పూర్ణాంక ఇవ్వాలని.
>> "వరకు రిపీట్" గుర్తు స్క్రాచ్ లో బ్లాక్?
మీరు ఇదే నిర్మాణం చేయవచ్చు సి లో ఒక "అయితే" లూప్ ఉపయోగించి
లేదా "అలా-అయితే" లూప్.
అయితే లూప్ నిర్మాణం ఒక పరిస్థితి ఉంది కోసం కలుసుకున్నారు తప్పక
అమలు లూప్ యొక్క శరీరం.
>> ఈ, ఒక చిన్న పోలి చూడండి ఉండాలి పరిస్థితి వలె ఎందుకంటే
కోణాలతో మొదటి బ్లాక్స్ మరియు బ్రాకెట్లలో లోకి వెళ్ళిపోతుంది
"అయితే" లూప్ యొక్క.
తద్వారా పరిస్థితి అని తనిఖీ చేస్తుంది పూర్ణాంక లోపల ఉంది
తగిన హద్దులు.
మీరు పూర్ణాంక ఉపయోగించి GetInt ప్రేరేపిస్తుంది ఆపై మీ "అయితే" అమలు
లూప్, పునరావృతమైన ప్రాంప్ట్ మరియు ముద్రణ సూచనలు, అయితే ఇన్పుట్
చెల్లదు.
>> సరైన యూజర్ ఇన్పుట్ నిర్ధారించడానికి మరో మార్గం ఒక "మీరు అయితే" లూప్ ఉపయోగించి
ఇది ఒక సమయంలో లూప్ చాలా పోలి ఉంటుంది.
"అలా-అయితే" లూప్ కోడ్ అమలు శరీరం వాటిని ఆపై తనిఖీలను లోపల
పరిస్థితి ఏర్పడితే లేదా అని.
ఈ, వినియోగదారు ఇన్పుట్ తీసుకోవటానికి ఉపయోగపడుతుంది మీరు అవసరం తెలుసు ఎందుకంటే
కనీసం ఒకసారి వాటిని ఫలితానికి.
పరిస్థితి హజరు కాకపోతే, కార్యక్రమం తరువాత లైన్ అమలు అవుతుంది
మీ "అలా-అయితే" లూప్.
పరిస్థితి అయితే ఏర్పడితే, లూప్ పునరావృతం
>> యూజర్ నిర్ధారించడంలో ఒక "అలా-అయితే" లూప్ ఇన్పుట్ ఈ వంటి ఏదో కనిపిస్తాయని.
నేను ఒక వేరియబుల్ n, GetInt ప్రకటించి, n చెల్లుబాటు అయ్యే వరకు అప్పుడు పునరావృతం.
మరియు ఈ ప్రక్రియ, నేను వివరించారు, ఉపయోగించి జరిగినది పూర్ణాంక-డేటా రకం, ఇది
మీరు నెల రోజులు ఉపయోగిస్తాము.
కానీ మనకు తెలుసు, నాణేలు సంఖ్య క్రమంలో కాబట్టి, త్వరగా పైల్ ఉంటుంది
పెద్ద సంఖ్యలను నిల్వ, డేటా రకం ఉపయోగించడానికి LongLong, కానీ అదే గుర్తు
ధ్రువీకరణ సూత్రం వర్తిస్తుంది.
>> అద్భుతం, కాబట్టి ఒకసారి మేము రెండు చెల్లుబాటులో కలిగి యూజర్ ఇన్పుట్లను -
నెలలో రోజుల మరియు పెన్నీలు మొదటి రోజు -
మేము తదుపరి లోకి వెళ్ళవచ్చు కార్యక్రమంలో భాగంగా.
మొదటి రోజు, వినియోగదారు మొదలవుతుంది ప్రత్యేక అయితే అనేక నాణేలు
మరియు నాణేలు మొత్తం వారు తదుపరి రోజు అందుకుంటారు రెట్టింపు.
కనుక ఇది ట్రాక్ అర్ధమే ఈ రెండు మొత్తంలో -
యూజర్ ఉంది మరియు ఎలా ఎంత డబ్బు అనేక నాణేలు వారు ఇవ్వబడుతుంది.
>> ఇప్పుడు, 28 31 రోజులు ఏదో చేయడం పునరావృత ఉంది, కాబట్టి యొక్క ఒక "కోసం" ఉపయోగించడానికి అనుమతిస్తున్నట్లు
లో రోజుల పాటు iterate లూప్ నెల, మొత్తం మరియు పెన్నీ నవీకరించుటకు
ప్రతి సమయం జోస్యం.
లూప్ సింటాక్స్ కలిగి "కోసం" కింది -
ఒక ప్రారంభ, ఒక పరిస్థితి, మరియు ఒక నవీకరణ.
మీ "కోసం" లూప్ ప్రారంభించడం ఉంటుంది ఒక వేరియబుల్, అది
మొదటి లూప్ ప్రవేశిస్తుంది.
పరిస్థితి ఏర్పడితే, శరీరం లూప్ యొక్క అమలు అవుతుంది.
తరువాత, నవీకరణ అమలు అవుతుంది.
పరిస్థితి ఇప్పటికీ ఏర్పడితే, లూప్ అమలు మరియు అప్ డేట్ చేస్తుంది
కాలం మీ పరిస్థితి, పునరావృతం నిజమైన కు అంచనాలు.
>> ఇక్కడ ఒక విభజిస్తుంది ఒక "కోసం" లూప్ వార్తలు 2 10 సార్లు మొత్తం ద్వారా పూర్ణాంక p.
నేను పూర్ణాంక p ప్రకటించింది ఎలా గమనించండి నా "కోసం" లూప్ వెలుపల, తద్వారా
పూర్ణాంక పొందవచ్చు "కోసం" లూప్ బయట.
నెల ఆమోదించింది తర్వాత, సమయం యూజర్ చెప్పడానికి ఎంత డబ్బు
వారు సంపాదించిన చేసిన.
స్పెక్ ప్రతి, మీరు యూజర్ చెప్పడానికి అవసరం ఎన్ని డాలర్లు, కాదు ఎన్ని
పెన్నీలు, వారు కలిగి.
కానీ ఇప్పటివరకు, మీరు ట్రాక్ ఉంచింది చేసిన మొత్తం మరియు LongLongs ఉపయోగించి పెన్నీలు,
పూర్ణ సంఖ్యలు చెప్పవచ్చు.
>> $ 1 కు 100 పెన్నీలు కాబట్టి, అక్కడ తప్ప పెన్నీలు సంఖ్య ఒక
100 బహుళ, మీరు చెయ్యాలి దశాంశ స్థలాలు సూచిస్తాయి.
రెట్టింపు autotype అనుమతిస్తుంది మీరు దీన్ని.
సో ఎలా మేము ప్రాతినిధ్యం మార్చడంలో లేదు డాలర్లకు పెన్నీలు?
>> యొక్క పరిశీలించి లెట్ pi.c.
ఈ కార్యక్రమం ఒక LongLong big_pi మరియు పడుతుంది 100,000 ద్వారా విభజిస్తుంది, మరియు ముద్రిస్తుంది
ఐదు దశాంశ స్థానాల వరకు ఫలితంగా.
మేము నాలుగు దశాంశ ప్రదర్శించడానికి కోరుకుంటే స్థలాలు, అప్పుడు మేము కేవలం ఈ భర్తీ చేయవచ్చు
ఇక్కడ సంఖ్య.
సో యొక్క సేవ్ pi కంపైల్ మరియు తెలపండి అప్పుడు, ఫలితంగా చూసిన మేము
3,1415 అని ఆశించే -
pi మొదటి ఐదు అంకెలు.
>> ఇది అయితే కాదు.
మరియు ఎందుకు?
బాగా, big_pi, ఒక LongLong ఎందుకంటే మొత్తం సంఖ్య, ఇది ఇది లేదు
దశాంశాలు ట్రాక్.
నేను అవసరం మార్పు తయారు విభాగం ఉంది.
నేను ముందు ఇక్కడ ఒక డబుల్ నటించాడు అవసరం డబుల్స్ ఉంచేందుకు ఎందుకంటే, విభజన
దశాంశ స్థానాల ట్రాక్.
మరియు నేను ఒక కొత్త లైనును వెళుతున్న ఇక్కడ మంచి ఫార్మాటింగ్ కోసం.
>> మరియు ఇక్కడ మేము కలిగి -
3,1416.
మీరు 3.1416 ముద్రిస్తుంది ఆ గమనిస్తారు బదులుగా 3,1415 నాటికి అంచనా.
సమయంలో ఎందుకంటే రౌండ్లు ఆ డివిజన్ ప్రక్రియ, కేవలం వ్యతిరేకంగా
విలువ తగ్గిస్తోంది.
ఇప్పుడు మీరు ముద్రించడానికి ఉండాలి పూర్తి ఇది సరిగ్గా చివరి మొత్తం,
కార్యక్రమం.
>> అభినందనలు.
నా పేరు Zamyla ఉంది.
మరియు ఈ నాణేలు ఉంది.
>> [సంగీతాన్ని]