>> [MUSIC ప్లే]
>> రాబ్ బౌడెన్: ఇది, రాబ్ నాకు.
యొక్క ఎలా నడవడానికి లెట్ మారియో అమలు.
కాబట్టి మేము ఏమి చేయాలి మొదటి విషయం ఇన్పుట్ కోసం వినియోగదారు.
>> మేము ఎలా వారిని అడగాలి పొడవైన పిరమిడ్ ఉండాలి.
ఇక్కడ, మేము మేము చేస్తున్నా చూడండి ఎత్తు = GetInt.
ఒక మరియు గుర్తున్నది GetInt ఫంక్షన్ CS50 అమలవుతుంది
లైబ్రరీ, కాబట్టి టాప్, మేము అవసరం # గుర్తుంచుకోండి cs50.h. ఉన్నాయి
>> ఎందుకు మేము ఈ చుట్టి ఉన్నాయి ఒక డో-సమయంలో లూప్ లో?
బాగా, మేము కూడా గుర్తుంచుకోవాల్సిన అవసరం యూజర్ యొక్క ఇన్పుట్ చెల్లదు ఉండాలి.
చెల్లని ఇన్పుట్ ఉంది?
బాగా pset స్పెక్ ప్రత్యేకంగా చెప్పారు ఒక ఎత్తు తక్కువ కంటే 0 లేదా ఎక్కువ
23 చెల్లదు కంటే.
>> కాబట్టి ఇక్కడ, మేము నిర్వచించు చూసాము తో MAX_HEIGHT స్థిరమైన అని
23 విలువ.
దీన్ని-సమయంలో లూప్ అయితే కొనసాగుతుంది ఎత్తు కంటే తక్కువ 0 లేదా MAX_HEIGHT ఉంది
అంటే ఎత్తు, కంటే తక్కువ 23 ఎత్తు కంటే తక్కువగా ఉంటుంది.
ఎత్తు 24 లేదా ఎక్కువ ఉంటే కాబట్టి, మేము మళ్ళీ వెతికినా కొనసాగుతుంది అన్నారు.
గుర్తుంచుకోండి ఉచ్చులు అందంగా ఉంటాయి ఉపయోగపడిందా మేము పొందుటకు కావలసినప్పుడు
యూజర్ ఇన్పుట్ మరియు అప్పటి నుండి, ప్రమాణీకరించడానికి మేము అనివార్యంగా వద్ద యూజర్ అడగాలి
కనీసం వారు విలువ కోసం.
>> కాబట్టి ఒకసారి మేము వారి ఇన్పుట్ కలిగి, మేము ఇప్పుడు పిరమిడ్ నిర్మించవచ్చు.
ఈ సమస్య సెట్ యొక్క మాయలు ఒకటి మేము ఎగువన ప్రారంభించడానికి కలిగి
పిరమిడ్.
మీరు దిగువన printf కాదు పిరమిడ్ ఆపై మీ మార్గం అప్ నిర్మించడానికి.
కాబట్టి యొక్క ఉదాహరణ చూద్దాం pset స్పెక్ నుండి.
>> మేము ఇక్కడ చూసే మేము ఒక ఎత్తు ఎంటర్ 8 యొక్క చాలా దిగువ
పిరమిడ్ తొమ్మిది hashes ముద్రిస్తుంది.
నుండి ఒక స్థాయి అప్ ముద్రలు ఒక ఖాళీ మరియు ఎనిమిది hashes.
నుండి ఒక స్థాయి రెండు ప్రదేశములలో ఉంది ఏడు hashes, అన్ని మార్గం వరకు మేము
ఇది పిరమిడ్, యొక్క టాప్ ను ఏడు ముద్రిస్తుంది ఎనిమిది స్థాయిలు,
ప్రదేశములలో రెండు హష్లు.
కాబట్టి మేము కలిగి గుర్తుంచుకోవాలి మొదటి ఈ టాప్ లెవెల్.
>> ఇక్కడ మేము నుండి iterating చేస్తున్నారు ఉన్నత స్థాయిలో, వరుసగా 8, నిరంతర
వరుస 0 చేరుకునే వరకు.
కాబట్టి ఎలా మేము అనేక ప్రదేశాలు అవసరం లేదు టాప్ వరుసగా ప్రింట్?
మేము ఏడు ఖాళీలు ముద్రించిన మరియు రెండు హష్లు.
కాబట్టి మేము మీరు ఖాళీలు సంఖ్య ఉంది మైనస్ 1 పట్టుకొనియున్న వరుసగా.
>> పై వరుస 8, 8 మైనస్ ఉంటే 1 మాకు ఏడు ఖాళీలు ఇస్తుంది.
అప్పుడు మేము ముద్రిస్తుంది ఒక లూప్ కలిగి ఒక సమయంలో ప్రతి స్పేస్ ఒకటి.
కాబట్టి ఖాళీలు ఈ లూప్, 7 ఏడు సార్లు, ముద్రణ
ఏడు వ్యక్తిగత ప్రదేశాలను.
>> కాబట్టి ఇప్పుడు మేము ఈ hashes ప్రింట్ అవసరం పిరమిడ్ చివరిలో.
ఇక్కడ, మేము లెక్కించేందుకు అవసరం hashes సంఖ్య.
మేము మేము ఎత్తు చేస్తున్న చూడండి మైనస్ వరుసగా ప్లస్ 2.
కాబట్టి మేము ఎలా ఆ వచ్చింది?
>> గుర్తుంచుకోండి పిరమిడ్ పైన వరుసగా 8 మరియు ఎత్తు 8.
మరియు మేము ఇంకా రెండు హష్లు ముద్రించిన.
చాలా కనీసం, 8 మైనస్ 8 ప్లస్ 2 మాకు సరైన సమాధానం ఇస్తుంది.
ఆపై దిగువ పరిగణలోకి పిరమిడ్, 1 వరుస.
ఎత్తు మైనస్ వరుసలో 7 ఇవ్వాలని, మరియు అప్పుడు ప్లస్ 2 మాకు తొమ్మిది hashes ఇస్తుంది,
ఇది ఖచ్చితంగా సంఖ్య మేము ముద్రిత hashes.
ఈ మేము కావలసిన సూత్రం సంఖ్య లెక్కించేందుకు ఉపయోగించే
ప్రతి వరుసలో hashes.
>> ఆ సంఖ్య ఉపయోగించి, మేము వేరొక కలిగి కు సమానమైన లూప్, కోసం
ఫైళ్ళను కోసం ఉపయోగించిన లూప్, ఆ hashes సార్లు iterates సంఖ్య
ఒక హాష్ ప్రతి సమయం ప్రింటింగ్.
పై వరుసలో, ఆ చేస్తాము రెండు హష్లు ప్రింట్.
వరుసను పైన, ఆ చేస్తాము తొమ్మిది hashes ప్రింట్.
మరియు ప్రతి ఇతర వరుసగా ప్రతి ముద్రిస్తుంది మధ్య లో hashes సంఖ్య.
>> మరియు తర్వాత చాలా చివరిలో, మేము అవసరం తదుపరి వెళ్ళడానికి మా కొత్త లైన్ ప్రింట్
పిరమిడ్ లో వరుస.
చివరగా, మేము కొత్త లైన్ ప్రింట్ అవసరం వరుసగా చివర క్రమంలో వద్ద
తదుపరి కొనసాగుతుంది పిరమిడ్ వరుసగా.
మరియు మా కార్యక్రమం చివరిలో, మేము తిరిగి 0 కలిగి.
>> Pset స్పెక్, తిరిగి ప్రకారం 0 ఖచ్చితంగా అవసరం లేదు.
కానీ ప్రధాన జరుగుతుంది సూచిస్తుంది లేదు.
నా పేరు రాబ్ ఉంది, మరియు ఈ మారియో ఉంది.
>> [MUSIC ప్లే]