ZAMYLA చాన్: ఇది ఒక నాకు, Zamyla ఉంది.
మారియో నేడు, మేము చేయబోతున్నామని మారియో సగం పిరమిడ్ గీయడం
అప్ అధిరోహించిన.
>> కాబట్టి యొక్క మాట్లాడటానికి వీలు మా ఈ సమస్య కోసం చేయవలసిన యొక్క.
మేము చూడాలని ప్రాంప్ట్ మరియు ధ్రువీకరించడానికి
ఎలా ఒక చెల్లుబాటు అయ్యే ఇన్పుట్ వినియోగదారుని అధిక వారు మారియో యొక్క పిరమిడ్ ఉండాలనుకుంటున్నాను.
ఆపై, మేము వాటిని డ్రా చూడాలని.
కాబట్టి యొక్క ప్రాంప్ట్ ప్రారంభించడానికి వీలు మరియు వారి ఇన్పుట్ కోసం యూజర్ నిర్ధారించడంలో.
>> మేము వుపయోగించవచ్చు CS50 లైబ్రరీ ఫంక్షన్
నిర్థారిస్తుంది ఆ Int పొందండి యూజర్ ఇన్పుట్లను పూర్ణాంకం.
ఏదైనా ధనాత్మక పూర్ణాంకాలు, ప్రతికూల పూర్ణ సంఖ్యలు, సంఖ్య 0 అన్ని ఫెయిర్ గేమ్.
లేకపోతే, వాడుకదారుడు అడుగబడును వారు ఇన్పుట్ ఒక చెల్లుబాటు అయ్యే పూర్ణాంక వరకు మళ్ళీ.
ఇప్పుడు అయితే మరియు ప్రధానంగా చేస్తుంది మాకు పని చాలా
భరోసా ఆ యూజర్ మాకు పూర్ణాంకం ఇస్తుంది,
మేము ఇంకా కొన్ని దరఖాస్తు అవసరం ఆ అదనపు అడ్డంకులు.
అన్ని తరువాత, మేము మారియో క్లైంబింగ్ ఉండకూడదు ప్రతికూల 12 ఎత్తు ఒక సగం పిరమిడ్.
>> దీనికి తోడు, సమస్యను స్పెసిఫికేషన్
మేము మాత్రమే చెప్పేవారు మారియో అధిరోహించిన అనుమతించదు
0 మరియు 23 మధ్య ఎత్తులు ఒక పిరమిడ్.
OK, కాబట్టి మేము అవసరం అర్థం నిరంతరం యూజర్ ప్రాంప్ట్
మాకు ఒక చెల్లుబాటు అయ్యే ఇవ్వాలని సంఖ్య మరియు మాత్రమే కొనసాగుతుంది
వారు మాకు ఒక చెల్లుబాటు అయ్యే ఎత్తును ఇచ్చాను ఒకసారి.
మేము ఆ చేయాలి?
>> బాగా, నిరంతర ప్రక్రియలకు మాకు ఇవ్వాలని loops-- చేయడం ఏదో ఆలోచన
మళ్లీ మళ్లీ.
కాసేపు సి లో ఒక లూప్ లూప్ అని నిరంతరం రెడీ
కాలం లూప్ యొక్క శరీరం అమలు నిర్దిష్ట పరిస్థితి ఒప్పుకు మదింపు.
వెంటనే ఆ షరతు తప్పుకు మదింపు,
కార్యక్రమం ముందుకు చేస్తుంది సంసార ఆ తర్వాత వస్తుంది.
ఉచ్చులు ఒకటి మార్గంలో ఉన్నప్పుడు కాబట్టి నిరంతరంగా మేము భరోసా
చెల్లుబాటు అయ్యే ఇన్పుట్ వినియోగదారుని అడుగుతుంది.
మరియు వారు మాకు ఒక చెల్లుబాటు అయ్యే ఇన్పుట్ ఇవ్వాలని ఒకసారి మేము తదుపరి వస్తుంది సంసార ముందుకు వస్తుంది.
మేము అడిగే చూడాలని తెలుసు ఇన్పుట్ కోసం వినియోగదారు కనీసం ఒకసారి.
కాబట్టి ఇప్పుడు మేము ఒక సోదరి వచ్చిన అయితే లూప్, దో-సమయంలో లూప్ ఉంది.
>> ఉచ్చులు నిర్వర్తిస్తుంది డు లూప్ యొక్క శరీరం, కనీసం.
కాబట్టి పరిస్థితి తనిఖీ లేకుండా, అది లూప్ యొక్క శరీరం అమలు చేస్తుంది.
ఆపై చూడటానికి తనిఖీ పరిస్థితి అయినా కూడా పునరావృతం అవసరం.
ఈ సులభ వస్తుంది మేము వినియోగదారు ఇన్పుట్ నిర్ధారించడంలో చేస్తున్నారు.
మేము వెళుతున్న తెలుసు కనీసం ఒకసారి వారిని అడగండి.
కాబట్టి ఒక డో-సమయంలో లూప్ ఉండవచ్చు ఈ వంటి ఏదో చూడండి.
మేము ఒక పూర్ణాంకం n కలిగి.
మరియు డో యొక్క లోపల సమయంలో లూప్, మేము వెంటనే
పూర్ణాంకం కోసం వినియోగదారు ప్రాంప్ట్.
n చెల్లని ఉంటే, అప్పుడు మేము వాటిని ప్రాంప్ట్ మళ్ళీ మళ్ళీ మళ్ళీ అవి వరకు
మాకు ఆ చెల్లుబాటు అయ్యే పూర్ణాంక ఇవ్వాలని.
చివరగా, ఒకసారి n చెల్లుబాటు అయ్యే ఇన్పుట్, మేము చేస్తాము మా కార్యక్రమం మిగిలిన వెళ్లండి.
>> కాబట్టి యొక్క వివరాలను మరియు చెక్ వినుడు ఏమి ఒక చెల్లుబాటు అయ్యే ఇన్పుట్ కోసం పరిస్థితులు
అవతరిస్తుంది.
చెల్లుబాటు అయ్యే ఎత్తును వెళ్తున్నారు 0 మరియు 23 మధ్యలో ఉంటుంది.
కాబట్టి చెల్లని ఎత్తులు వెళ్తున్నారు 0 కంటే తక్కువ లేదా కంటే ఎక్కువ 23 ఉంటుంది.
కాబట్టి రూపొందించడానికి గుర్తు మీ పరిస్థితి జాగ్రత్తగా
పరిస్థితి తెలుసుకోవడం అయితే లూప్
n చెల్లదు అయితే ఉండాలి.
ఇప్పుడు ఈ ఒక అవతరిస్తుంది లేదు సులభమైన ఒక్క బూలియన్ వ్యక్తీకరణ.
మేము జతచేసే చూడాలని రెండు భిన్న భావాలు
మా మొత్తం పరిస్థితి చేయడానికి.
>> కాబట్టి యొక్క కేవలం నేను చేసిన ఒక నిజం పట్టిక చూద్దాం ఇప్పటికే మీరు మేము ఉన్నాము అని సూచన ఇచ్చారు
రెండు Booleans వ్యవహరించే కావడం.
కాబట్టి ఇక్కడ ఒక నిజం పట్టిక ఎక్కడ నేను ఇద్దరు Booleans-- బూలియన్ 1 మరియు 2.
కాబట్టి మేము విశ్లేషించడానికి అవకాశం ఉంటుంది bool1 మరియు bool2 లేదా bool1 లేదా bool2.
మరియు మాత్రమే రెండింటికీ నిజమైన ఉంటుంది బూలియన్ అన్ని అయితే, నిజమైన కు అంచనా
లేదా ఒకటి ఉన్నంత నిజమైన ఉంటుంది రెండు Booleans ఒప్పుకు మదింపు.
OK, కాబట్టి ఒక క్షణం పడుతుంది, ఈ విరామం వీడియో మరియు ఈ నిజం పట్టిక జీర్ణం చేస్తాయి.
నేను ఇక్కడే వేచి ఉంటాం.
మీరు తిరిగి వచ్చినప్పుడు, చూడండి మీరు కలిసి ముక్క ఉంటే
ఒక బూలియన్ వ్యక్తీకరణ మీ n యొక్క పరిస్థితి చెల్లని ఇన్పుట్ ఉండటం.
>> కాబట్టి ఇప్పుడు మేము కలిగి చెల్లుబాటు అయ్యే వినియోగదారు ఇన్పుట్, లెట్స్
ముందుకు వెళ్లి మేము ఎలా గురించి మాట్లాడండి సగం పిరమిడ్ డ్రా ఉండవచ్చు.
ఇక్కడ ఈ సాధారణ టెక్స్ట్ ఎడిటర్ లో, నేను ఒక ఎడమ మండలం పిరమిడ్ డ్రా చేసిన.
కానీ మేము మా అవసరం తెలుసు పిరమిడ్ కుడి సమలేఖనమైంది వుంటుంది.
కాబట్టి నేను ఈ ఎలా ఉండవచ్చు?
Well, నేను పుష్ ప్రయత్నించండి వైపు ప్రతిదీ
కొంచెం పెడతాడు మధ్య లో పాత్ర.
ఆపై, తదుపరి పంక్తి, నేను చాలు వెళుతున్న
అది వెంట కొట్టాలని కొన్ని ఎక్కువ అక్షరాలు, మరియు further-- అందువలన న మొదలగునవి
నేను కుడి సమలేఖనమైంది పిరమిడ్ వరకు.
కాబట్టి మేము ఒక సరైన సమలేఖనం పిరమిడ్ ఉన్నాయి, కానీ ఇది చుక్కలు తో చాలా గొప్పది కనిపించడం లేదు.
కానీ మేము ఇంకా కావలసిన ఆ nice అంతరాన్ని నిర్వహించడానికి.
నేను అక్షరాలా వెళుతున్న కొన్ని ఖాళీలు ఇన్సర్ట్.
>> బదులుగా మూడు చుక్కలు, నేను చేస్తాము ఒకటి, రెండు, మూడు ప్రదేశాలు చాలు.
రెండో లైన్లో.
నేను ఒకటి, రెండు ఖాళీలు ఉంచుతాము.
మరియు రెండవ చివర న పంక్తి, కేవలం ఒక స్థలం.
మరియు ఇక్కడ నేను ఒక కుడి సమలేఖనమైంది పిరమిడ్ ఉన్నాయి.
టెక్స్ట్లో ఉదాహరణ చేయడం నుండి ఎడిటర్, మేము నమూనా కోసం ఒక ఆలోచన
మేము సగం పిరమిడ్ డ్రా ఉపయోగిస్తాము.
ప్రతి వరుస, మేము అదే చేసింది మేము కొన్ని ఖాళీలు టైప్ ఉంది,
ఆపై టైప్ కొన్ని హాష్లు, ఆపై టైప్
ఎంటర్ మీట ఒక కొత్త లైన్ సృష్టిస్తుంది.
కాబట్టి ఇప్పుడు మేము ఆ కలిగి, యొక్క వీడలేదు ఒక అడుగు ముందుకు మరియు ఒక నమూనా కనుగొనేందుకు.
>> కాబట్టి నేను, చెప్పడానికి వెళుతున్నాను ఈ ఉదాహరణ యొక్క ఆసక్తి
మేము 8 ఎత్తు వ్యవహరించే చేస్తున్నారు.
మొదటి వరుసలో రెండు అన్నారు ఏడు ఖాళీలు అనుసరిస్తుంది హష్లు.
రెండవ మూడు హష్లు, ఆరు ఖాళీలు.
మూడో వరుస నాలుగు హష్లు, ఐదు spaces-- అందువలన న మొదలగునవి
మేము n వ వరుస వచ్చేవరకు.
కాబట్టి అప్పుడు, నేను n వ వరుస కోసం మీరు అడగండి, ఎన్ని హష్లు మేము కలిగి వెళ్తున్నారు
మరియు ఎన్ని ఖాళీలు?
కాబట్టి దీనిని దొరుకుతుందని మీకు అనిపిస్తుంది సూత్రం ఎన్ని హష్లు ప్రాతినిధ్యం
మరియు ఎన్ని ఖాళీలు అవసరమైన N వ వరుసగా మీరు కొన్ని ఎత్తు కలిగి ఉన్నప్పుడు.
>> ఇప్పుడు మీరు ఈ ఇందుకు చేసినప్పుడు, మీరు సూచి చేస్తున్నారు జాగ్రత్తగా ఉండండి.
నేను ఈ అర్ధం ఉంది మాకు అన్ని రోజువారీ జీవితంలో
సాధారణంగా, లెక్కింపు 1 ప్రారంభించండి.
CS50 లో కానీ, కంప్యూటర్ సైన్స్లో సాధారణంగా, మేము 0 సూచి.
కాబట్టి మొదటి వరుస ఉంటుంది 0 యొక్క n 1 వ్యతిరేకంగా.
మీరు ఈ స్ప్రెడ్ జాగ్రత్తగా ఉండండి మీ నమూనా దొరుకుతుందని ఆశించాను.
కాబట్టి ఇప్పుడు యొక్క ఎంత తిరిగి వీడలేదు మేము మా పిరమిడ్ డ్రా చూడాలని.
ప్రతి వరుస కోసం, మేము చూడాలని ఖాళీలు ప్రింట్ హష్లు ప్రింట్
ఆపై ఒక కొత్త లైన్ ప్రింట్.
ఇక్కడ సూచనను ఉంది ప్రతి వరుసలో "కోసం" పదం.
సి లో, మేము ఒక నిర్మాణం చేసారు లూప్ ఒక అని,
ఒక ఉన్నాయి ఇది ప్రారంభ, ఒక పరిస్థితి, ఒక నవీకరణ,
మరియు లూప్ యొక్క శరీరం.
>> నేను చెప్పేది కావలెను హలో చెప్పండి ప్రపంచ 50 సార్లు లూప్ నా,
ఈ వంటి ఏదో చూస్తారు.
నేను 0 నా పూర్ణాంక ప్రారంభించడం.
పరిస్థితి నేను 50 కంటే తక్కువ అని.
అప్పుడు నా నవీకరణ కేవలం ఉంది ఒకటి ప్రతిసారీ నేను పెంచడం.
మేము కూడా ఉచ్చులు కోసం ఉపయోగించవచ్చు విషయాలు పైగా iterate.
మేము కలిగి ఎంత ఇక్కడ గమనించవచ్చు హార్డ్ అనేక కోడెడ్
కానీ వేరియబుల్ ఉంచుతారు బదులుగా స్థితిలోకి ఎత్తు.
సో నేను ఇక్కడ చేస్తున్నానో నాకు iterating ఉన్నాను ఉంది పిరమిడ్ ప్రతి వరుసలో మీద.
నేను ప్రతి ఏదో ఒకటి చెయ్యాలి నా లూప్ యొక్క శరీరం లోపల వరుస.
>> మేము లోపల ఏం చేస్తున్నారు లూప్ యొక్క శరీరం?
Well, మేము ఇప్పటికే చెప్పారు వంటి, మేము ప్రింటింగ్ ఖాళీలు మరియు మేము హాష్లను ప్రింటింగ్
మరియు మేము ఒక కొత్త లైన్ ముద్రణ చేస్తున్నారు.
లూప్ నా బాహ్య కాబట్టి ఇలా కనిపిస్తుంది.
నేను ప్రతి వరుసలో మీద iterate పిరమిడ్, ఉపయోగించి,
ఈ సందర్భంలో, వేరియబుల్ ఎత్తు ఆ పిరమిడ్ ఎత్తు నిల్వ.
ఆ లూప్ యొక్క శరీరం లోపల, నేను రెడీ పదేపదే ఖాళీలు ప్రింట్ అన్నారు ముద్రణ
పదేపదే హష్లు, ఆపై ఒక కొత్త లైన్ ప్రింట్.
>> కాబట్టి ఇప్పుడు, భావనలను అన్నింటినీ ఉపయోగించి నేను ఈ వాక్ ద్వారా గురించి మాట్లాడారు చేసిన,
మిమ్ములను ఉండాలి ఇన్పుట్ వినియోగదారుని ఇన్పుట్, సరిదిద్దడంలో,
మరియు అప్పుడు సగం పిరమిడ్ డ్రా.
>> నా పేరు Zamyla ఉంది, మరియు ఈ CS50 ఉంది.