SPEAKER 1: యొక్క నీటి గురించి చర్చిద్దాం.
ఈ సమస్య, మేము చెప్పడం అవ్వమని మాకు నిమిషాల్లో ఎంతకాలం వారి షవర్ ఉంది
ఆపై మేము సమానం లెక్కించేందుకు నీటి సీసాల సంఖ్య
వారి షవర్ ఉపయోగించారు.
>> సో వాట్ మా చేయవలసిన యొక్క ఉన్నాయి ఈ సమస్య కోసం?
మొదటి, మేము చూడాలని ప్రాంప్ట్ ఆపై ధ్రువీకరించడానికి
యూజర్ మాకు ఇచ్చే ఇన్పుట్.
ఒకసారి ఇది మాకు మేము హామీ చెల్లుబాటు అయ్యే వినియోగదారు ఇన్పుట్,
మేము లెక్కించేందుకు చూడాలని నీటి సీసాలు సమానం సంఖ్య
యూజర్ సమయంలో ఉందని వారి షవర్, ఆపై మేము ఉన్నాము
ద్వారా వాటిని మీరెప్పుడూ ఆ సంఖ్యను ముద్రించిన.
>> కాబట్టి యొక్క మా మొదటి పరిష్కరించడానికి వీలు పని ప్రోత్సహించాడు మరియు నిర్ధారించడంలో
యూజర్ ఇన్పుట్.
ఈ కోసం మేము రాసిన మీరు అని ఫంక్షన్
CS50 లైబ్రరీ లో ఉన్న get_int.
get_int ఆ యూజర్ ఇన్పుట్లను నిర్ధారిస్తుంది పూర్ణాంకం, ఏ అనుకూల సంఖ్యలు కాబట్టి,
వ్యతిరేక నంబర్లు, లేదా సున్నా అన్ని అనుమతించబడతాయి.
కానీ వినియోగదారు ఏదైనా ఇన్పుట్లను, కాబట్టి అక్షరాలు లేదా సంఖ్యల ఏ కలయిక
లేదా దశాంశ సంఖ్యలు, అప్పుడు యూజర్ తిరిగి ప్రయత్నించమని అడుగబడును
మరియు ఫంక్షన్ ఏదైనా అంగీకరించము వినియోగదారు వాటిని పూర్ణాంకం ఇస్తుంది వరకు.
>> కాబట్టి మేము ఎలా get_int ఉపయోగించగలను?
మీరు మీ కార్యస్థలం తెరిస్తే మరియు integer.c చేసుకుందాం అనే ఫైల్ సృష్టించడానికి
కింది టైప్ చేయండి.
హాష్ ట్యాగ్ cs50.h. ఉన్నాయి
ఈ get_int ఎందుకంటే అవసరం ఒక CS50 లైబ్రరీ ఫంక్షన్,
కాబట్టి మేము ఉన్నాయి హాష్ ట్యాగ్ ఉండాలి క్రమంలో దాని ప్రకటనను
ఫంక్షన్ ఉపయోగించడానికి.
అప్పుడు నా ప్రధాన నేను వెళుతున్నాను పని
కేవలం ఫంక్షన్ get_int కాల్.
>> కాబట్టి యొక్క ఈ అమలు అనుమతిస్తాయి మరియు అది ఎలా పని చేస్తుందో చూడండి.
నేను ఇప్పటికే అది సంకలనం చేసిన, కాబట్టి లెట్స్ కేవలం ముందుకు వెళ్లి ఈ కార్యక్రమం అమలు,
./పూర్ణ సంఖ్య.
ఇక్కడ నేను ఒక ప్రాంప్ట్ మరియు ఇక్కడ నేను ఇన్పుట్ పేరు విలువ.
నేను కొన్ని పూర్ణాంక చాలు సే, 50, కార్యక్రమం excepts వదిలేసి
మరియు ఆ ఆ.
>> కానీ నేను దాన్ని మళ్ళీ రన్ మరియు చెప్పినప్పుడు వేరే నేను ఇన్పుట్ ఏదో.
బహుశా ప్రపంచ హలో.
కాబట్టి పూర్ణాంకం కాదు ప్రోగ్రామ్ నాకు తిరిగి ప్రయత్నించమని అడుగుతుంది.
యొక్క మళ్లీ ప్రయత్నించండి లెట్ బహుశా ఈ సమయంలో దశాంశ.
0.5, మళ్ళీ, పూర్ణాంక కాబట్టి కార్యక్రమం అంగీకరించము
మరియు అది నాకు మళ్ళీ చెప్పండి చేస్తాము.
కాబట్టి యొక్క మరొక సంఖ్య ఇస్తాను.
కార్యక్రమం ఇది అంగీకరిస్తుంది, వదిలేసి, మరియు మేము పూర్తి చేసిన.
>> కాబట్టి ఇప్పుడు మేము ఒక ఫంక్షన్ కలిగి మాకు మరియు నిర్ధారిస్తుంది అనుమతిస్తుంది
యూజర్ ఇన్పుట్లను ఆ పూర్ణాంక, కానీ మేము ఎలా
నిజానికి ట్రాక్ పూర్ణాంక యూజర్ ద్వారా ఇన్పుట్?
బాగా, మేము చేస్తాము అన్ని స్టోర్ ఉంది ఒక కారకం ఈ విలువ, n చెప్పటానికే.
సో నేను ఒక పూర్ణాంకం n డిక్లేర్ ఉంటే, మరియు నేను get_int ఆ విలువ సెట్
ఆపై n ఆపై నిల్వ చేస్తుంది సంసార యూజర్ ఇన్పుట్ విలువ.
>> అన్ని కుడి, కాబట్టి ఇప్పుడు మేము అని నిర్ధారిస్తుంది చేసిన యూజర్ మాకు పూర్ణాంకం ఇస్తుంది
మరియు మేము ట్రాక్ ఎలా తెలుసు పూర్ణాంక, కానీ గుర్తుంచుకోవాలి,
పూర్ణాంకాల అనుకూల మరియు ప్రతికూల స్పందనలు రెండూ ఉంటాయి.
కనుక ఇది నిజంగా సమంజసం అనిపించుకోదు ఈ సమస్య యొక్క సందర్భం లో
వినియోగదారు ఒక షవర్ పడుతుంది ఆ యొక్క ప్రతికూల 12 నిమిషాల చెబుతాను.
కాబట్టి మేము వినియోగదారు నిర్ధారించుకోండి అవసరం వాస్తవానికి మాకు ఒక సానుకూల పూర్ణాంక ఇస్తుంది.
ఇప్పుడు మేము కేవలం లేదు ఆ కోసం ఒకే ఫంక్షన్,
కాబట్టి మేము చూడాలని మమ్మల్ని ఆ సృష్టించడానికి.
>> కాబట్టి మేము నిరంతరంగా కావలసిన వినియోగదారును ప్రాంప్ట్
వారు మాకు సానుకూల పూర్ణాంక ఇవ్వాలని వరకు.
నేను నిరంతరం ఏదో చేస్తున్నదాన్ని ఉంటే ఒక లూప్, ఒక పునరావృతం వంటిదని ఉంది.
మేము ఉపయోగించే నిర్మాణాలు ఒకటి కాబట్టి సి లో పునరావృతం మరియు ఉచ్చులు అమలు
కాసేపు లూప్ ఉంది.
సో ఒక సమయంలో లూప్, వంటి ఇక్కడ చూపిన నిర్వర్తిస్తుంది
సంసార లూప్ యొక్క శరీరం లో ఉంది నిర్దిష్ట పరిస్థితి వేసుకునే అంచనాలు కాలం
సత్యంకు.
వెంటనే ఆ షరతు అప్పుడు, తప్పుకు మదింపు
కార్యక్రమం ముందుకు చేస్తుంది సంసార లూప్ యొక్క శరీరం తర్వాత వస్తుంది.
>> ఉచ్చులు వెళ్తున్నారు అందువలన CS50 లో నిజంగా ఉపయోగకరంగా ఉంటుంది.
కానీ ఈ ముఖ్యంగా కేసు, మేము ఉన్నాము తెలుసు
కనీసం వినియోగదారును ప్రాంప్ట్ అన్నారు ఒకసారి మరియు అప్పుడు మాత్రమే లూప్ అవసరమైతే.
కాబట్టి ఇక్కడ ఒక వచ్చారు ప్రత్యేక నిర్మాణం మరియు ఆ
అయితే చాలా పోలి లూప్ ఒక డో-సమయంలో లూప్ అని.
>> కాబట్టి ఒక డో-సమయంలో లూప్ అమలు లూప్ యొక్క శరీరం, కనీసం
మరియు అప్పుడు అది చూసేందుకు తనిఖీ అది అమలు లేదో,
ఒక సమయంలో లూప్ వ్యతిరేకంగా, పరిస్థితి తనిఖీ చేస్తుంది
ఆపై శరీరం అమలు.
కాబట్టి ఒక డో-సమయంలో లూప్ లో మనం వాటిని అలా పూర్ణాంకం కోసం వినియోగదారు ప్రాంప్ట్ ఉంది,
ఆపై అది చెల్లదు అయితే లేదా తనిఖీ.
చెల్లని ఉంటే, అప్పుడు మేము చేస్తాము యూజర్ అడగడం విధానాన్ని పునరుక్తి
మాకు మరొక పూర్ణాంకం ఇస్తాయి, మరియు అప్పుడు ఆ పూర్ణాంక చెల్లదు మాత్రమే,
మేము కొనసాగిస్తాము సంసార తరువాత వస్తుంది.
>> ఇప్పుడు మీరు గమనించవచ్చు పూర్ణసంఖ్య n ప్రకటన
కొద్దిగా భిన్నంగా ఉంటుంది మనం మునుపటి ఉదాహరణలో ముందు చేశాడు
మరియు ఈ కారణంగా స్కోప్ ఉంది.
మేము లోపల పూర్ణాంకం n ప్రకటించారు డో-సమయంలో లూప్ యొక్క శరీరం యొక్క,
అప్పుడు మేము యాక్సెస్ చేయలేరు అని ఆ వంకర బయట n యొక్క ఆ విలువ
లూప్ యొక్క శరీరం సూచిస్తూ జంట కలుపులు.
కానీ మేము నిజానికి యాక్సెస్ అనుకుంటున్నారు n విలువ తరువాత మా కార్యక్రమం లో.
>> OK, కాబట్టి ఇప్పుడు యొక్క గురించి మాట్లాడటానికి వీలు ఈ పరిస్థితి ఏ విధంగా ఉండాలి.
మాత్రమే మేము reprompt కావలసిన యూజర్ కాలం n చెల్లదు వంటి.
కాబట్టి మీరే అనుకుంటున్నాను చెల్లని ఏమి పూర్ణ సంఖ్య విలువ లాగా
ఆపై ఒక బూలియన్ సృష్టించడానికి ఆ వ్యక్తం వ్యక్తీకరణ.
>> మేము దాదాపు మన subtask తో పనయ్యాక ప్రాంప్ట్ మరియు యూజర్ ఇన్పుట్ నిర్ధారించడంలో.
కాబట్టి యొక్క ఈ కొద్దిగా తయారు చేద్దాము బిట్ మరింత యూజర్ ఫ్రెండ్లీ
మరియు యూజర్ కొద్దిగా ఇవ్వాలని బిట్ మరింత సమాచారం
మనం వాటిని ప్రోత్సహించాడు.
కాబట్టి యొక్క శాతం, యూజర్ అడుగనివ్వండి స్పెక్ స్ట్రింగ్ నిమిషాలకు.
సో మీ printf ప్రకటనలు ఉపయోగించి, తయారు మీరు ఖచ్చితంగా ఈ మ్యాచ్ నిర్ధారించుకోండి.
>> అయితే సరే.
కాబట్టి ఇప్పుడు మేము ఒక చెల్లుబాటు అయ్యే యూజర్ ఇన్పుట్, ఒక సానుకూల పూర్ణాంక
ఎన్ని నిమిషాలు విలువ వారు షవర్ లో గడిపాడు.
కాబట్టి తరువాత ఏమిటి లెక్కించేందుకు ఉంటుంది సీసాలు సమానం సంఖ్య.
మనం ఇక్కడ ఏమి చూడాలని మొదటి వద్ద మీరు చాలా స్పష్టమైన,
మరియు ఆ సరే.
మనం చేయాలనుకుంటున్నారా మేము ఉంది సాధన ప్రారంభించడానికి కావలసిన
నమూనాలను గుర్తించడం ఆలోచన సమస్య కోసం సూత్రాలు అభివృద్ధి.
>> కాబట్టి మేము స్పెక్ ప్రతి చెప్పారు చేస్తున్నారు షవర్ లో అని ఒక నిమిషం
గురించి సమానం నీటి 12 సీసాలు.
ఆ విధంగా రెండు నిమిషాల చేస్తాను 24 సమానం,
ఐదు నిమిషాల చేస్తాను 60 సమానం.
కాబట్టి ఇప్పుడు మీరు అనుకుంటే మీరు వచ్చింది చేసిన, అప్పుడు చేసుకుందాం
మీరు పైకి వచ్చి లేదో చూడటానికి ఒక నమూనా లేదా ఫార్ములా
మేము చెప్పటానికి కలిగి ఉంటే వ్యక్తం, n నిమిషాలు, ఎన్ని నీటి సీసాలు
ఆ n పరంగా వ్యక్తం అవుతుంది?
>> మళ్ళీ, కూడా ఈ మొదటి వద్ద సాధారణ,
తరువాత మేము వెళ్ళాక న మరింత క్లిష్టంగా సమస్యలు
మేము పొందడానికి కావలసిన చూడాలని గుర్తించే పద్ధతి
నమూనాలు మరియు అభివృద్ధి సూత్రాలు ఈ విషయాలు బయటకు దొరుకుతుందని.
>> సి లో మీరు యాక్సెస్ ప్రామాణిక అంక కార్యకలాపాలు,
కూడిక, తీసివేత, గుణకారం మరియు భాగహారం.
కాబట్టి నేను చెప్పను మీరు ఇప్పుడు దొరుకుతుందని
వ్యక్తపరచటానికి ఎలా సీసాలు సమానం సంఖ్య
యూజర్ సేవించాలి వారి షవర్ సమయంలో.
>> అన్ని కుడి, మేము దాదాపు పూర్తి చేసిన.
మేము వారి ఇన్పుట్ వినియోగదారుని ప్రాంప్ట్ చేసిన, మేము అది చెల్లుబాటు అయ్యే ఇన్పుట్ అని నిర్ధారిస్తుంది చేసిన,
ఆపై మేము ఎలా కనుగొన్నారు చేసిన సమానమైన లెక్కించేందుకు
వారు వినియోగించిన సీసాల సంఖ్య.
అలా చేసిన చివరి విషయం అవుట్పుట్ ఉంది సీసాలు సమానం సంఖ్య
మరియు ఆశాజనక ప్రోత్సహిస్తున్నాము వాటిని కొన్ని నీటిని ఆదా చేసే.
>> విలువ ఉంటుంది ఔట్పుట్ ఒక printf ప్రకటన.
నేను మీరు నేను చెప్పడం కోరుకుంటే ఉదాహరణకు, మూడు పెంపుడు జంతువులు,
నేను ఒక printf ప్రకటన ఉపయోగించుకునే ఈ వంటి ఏదో కనిపిస్తోంది.
నేను మూడు పెంపుడు జంతువులు, మరియు ఒక కొత్త నైస్ ఫార్మాటింగ్ కోసం లైన్.
>> ఇప్పుడు మేము వద్దు కేవలం హార్డ్ కోడ్ విషయాలు.
సంఖ్య సే నా పెంపుడు జంతువులు కాలక్రమేణా మార్పులు.
అప్పుడు నేను వినియోగించుకోవచ్చు వెళుతున్న నా printf ప్రకటనలో placeholders.
ఇక్కడ నా సంఖ్య ఒక పూర్ణ సంఖ్య.
నేను ఒక ప్లేస్హోల్డర్ చేయడానికి వెళుతున్న % నేను ఉపయోగించి పూర్ణాంకం.
నేను స్ట్రింగ్ రాయాలో, మరియు తరువాత స్ట్రింగ్ తరువాత
నేను ఒక కామా మరియు వ్రాయడం నేను ముద్రించడానికి కావలసిన వేరియబుల్.
ఆ విలువ ప్రింట్ చేయబడుతుంది కాబట్టి ఆ ప్లేస్హోల్డర్% నేను బదులుగా లో.
>> మీరు, placeholders ఉపయోగించవచ్చు బాగా, ఒక% విదే తేలియాడుతున్న.
మీరు కూడా బహుళ ఉండవచ్చు ఒక స్ట్రింగ్ లో placeholders.
ఉదాహరణకు, నేను కొన్ని సంఖ్య ఉంటే కుక్కలు మరియు పిల్లుల కొన్ని సంఖ్య,
నేను ఇక్కడ మరియు తరువాత రెండు placeholders చాలు సంబంధిత క్రమంలో నా రెండు వేరియబుల్స్.
>> కాబట్టి ఇప్పుడు మేము ప్రింట్ ఎలా తెలుసు వేరియబుల్స్ నిల్వ విలువలు,
చాలా చివరి విషయం అలా మేము నిర్ధారించడానికి ఉంది
ఖచ్చితమైన ఫార్మాట్ విలువ ముద్రించడానికి వివరణలో సూచించింది.
అంతటితో ప్రాంప్ట్ చేసిన వినియోగదారు మరియు వారి ఇన్పుట్ చెల్లుబాటు.
మేము అప్పుడు సమానం లెక్కించిన చేసిన నీటి సీసాల సంఖ్య
వారు వారి షవర్ సమయంలో తింటాయి, మరియు మేము వాటిని ఆ విలువ outputted చేసిన.
అందువలన, మేము నీరు పూర్తి చేసిన.
>> నా పేరు [? Zamila?] మరియు ఈ CS50 ఉంది.