>> ZAMYLA చాన్: మారియో లోకి లెట్స్ జంప్.
మారియో మేము చేస్తాము పేరు ఒక కార్యక్రమం మా యొక్క సొంత, అయితే ఆదిమ, వెర్షన్
ఒక క్లాసిక్ సూపర్ మారియో బ్రదర్స్ ఆట నేపథ్యంలో.
ఈ సమస్య సెట్ కోసం, మేము చేయబోతున్నామని సగానికి పిరమిడ్ పునఃసృష్టి
మారియో న దూకడం.
మా కార్యక్రమం ఇంటరాక్టివ్ ఉంటుంది, కాబట్టి అది యూజర్ ఇన్పుట్ కొన్ని కు అడుగుతాము
పిరమిడ్ ఎత్తు.
మరియు కార్యక్రమం కి ముద్రిస్తుంది ఆ ఎత్తులో సగం పిరమిడ్, పేరు
దిగువ ఎడమ హాష్ దిగువన తో సర్దుబాటు టెర్మినల్ ఎడమ మూలలో
అవుట్పుట్ విండో.
>> , రెండు భాగాలుగా ఈ సమస్య విచ్ఛిన్నం యొక్క లెట్ ఒక, వినియోగదారు ఇన్పుట్, మరియు రెండు పొందుటకు
పిరమిడ్ అవ్ట్ ప్రింట్.
గుర్తుంచుకో ఆ అయితే GetInt ఫంక్షన్ పూర్ణాంకం తిరిగి ఉంటుంది, మీరు
ఈ ఇన్పుట్ చేస్తుంది నిర్ధారించుకోండి ఉంటుంది మీ ప్రోగ్రామ్ భావనను, కాబట్టి
మారియో, అది కేవలం ఒక చేయరు పూర్ణాంకం కోసం ఉత్పత్తి.
మీరు నిర్ధారించుకోండి చెయ్యాలి అని యూజర్ ఇన్పుట్లను లోపల ఒక పూర్ణాంకం
దిగువ మరియు ఎగువ హద్దులు మీరు ముద్రించవచ్చు ఆ పిరమిడ్.
ఈ వివరాలను ప్రతి, ఇది 0 మరియు 23 కలుపుకొని.
బయట యూజర్ ఇన్పుట్లను పూర్ణాంకం ఉంటే మా అంగీకరించిన హద్దులు, అప్పుడు మేము కావలసిన
మళ్ళీ ప్రాంప్ట్ మరియు మళ్ళీ వరకు వారు మాకు ఒక చెల్లుబాటు అయ్యే పూర్ణాంక ఇవ్వాలని.
>> సరైన యూజర్ ఇన్పుట్ నిర్ధారించడానికి ఒక మార్గం ఒక దో ఉండగా లూప్ ఉపయోగించి, ఇది
ఒక సమయంలో లూప్ పోలిన.
డు ఉండగా లూప్ కోడ్ అమలు శరీరం లోపల ఒకసారి, ఆపై తనిఖీ
పరిస్థితి ఏర్పడితే లేదా అని.
ఈ వినియోగదారు ఇన్పుట్ తీసుకోవటానికి ఉపయోగపడుతుంది మీరు అవసరం తెలుసు ఎందుకంటే
కనీసం ఒకసారి వాటిని ఫలితానికి.
పరిస్థితి హజరు కాకపోతే, కార్యక్రమం తరువాత లైన్ అమలు అవుతుంది
మీ దో ఉండగా లూప్.
పరిస్థితి ఏర్పడితే, అయితే, లూప్ పునరావృతం.
>> యూజర్ నిర్ధారించడంలో ఒక దో ఉండగా లూప్ ఇన్పుట్ ఈ వంటి ఏదో కనిపిస్తాయని.
నేను ఒక వేరియబుల్ n, GetInt, డిక్లేర్ మరియు n వరకు రిపీట్ చెల్లదు.
మీరు డిక్లేర్ ఉన్నప్పుడు గుర్తుంచుకోండి మీ వేరియబుల్, అది సరైన అవసరం
కేవలం స్క్రాచ్ మాదిరిగా పరిధిని,.
నా దో ఉండగా లూప్ లోపల n డిక్లేర్ ఉంటే, కార్యక్రమం మిగిలిన వుండదు
ప్రాప్యత చెయ్యగలరు.
ఇది పరిమితుల్లో పరిమితం లో గిరజాల కలుపులు యొక్క.
>> అన్ని కుడి, కాబట్టి ఇప్పుడు మేము ప్రామాణికం చేసిన యూజర్ యొక్క ఇన్పుట్, మేము నిజానికి అవసరం
ఈ సగం పిరమిడ్ డ్రా.
ఇది ముద్రిత అక్షరాలు తయారు, కాబట్టి యొక్క యొక్క ఒక సాధారణ లో ఒక సగం పిరమిడ్ చేయడానికి వీలు
టెక్స్ట్ ఎడిటర్.
మేము ఒక మారియో శైలి పిరమిడ్ చేయాలనుకుంటే ఎత్తు సర్దుబాటు చేసే మూడు
అప్పుడు మా విండో ఎడమ వైపున మేము రెండు hashes టైప్ ఇష్టం,, క్లిక్ చెయ్యండి
అప్పుడు మూడు hashes టైప్ చేయండి ఎంటర్, మరియు అప్పుడు నాలుగు టైప్ చేయండి.
>> కానీ ఈ సమస్య సెట్ లో, మా సగం పిరమిడ్ కుడి సమలేఖనమైంది వుంటుంది.
ఎలా, ఒక ప్రామాణిక కీబోర్డ్ ఉండవచ్చు ఉపయోగించి మీరు hashes తరలించడానికి ఈ ఫైలు సవరించడానికి
పైగా కుడి వైపు?
నేను, అండర్ రెండు ఉపయోగించవచ్చు పై వరుస మరియు రెండవ లో ఒక.
కనుక, అయితే, వంటి nice అనిపించడం లేదు యొక్క అండర్ స్థానంలో తెలపండి
ఖాళీలు, మరియు అక్కడ మేము ఒక సగం పిరమిడ్ కలిగి ఎత్తు మూడు.
>> ఈ టెక్స్ట్ ఎడిటర్ ప్రయత్నించండి మరియు గుర్తుంచుకోవాలి మీరు తిరిగి ఆలోచిస్తూ మొదలు ఉదాహరణకు
సి యొక్క ప్రయత్నించండి మరియు కొన్ని దొరుకుతుందని లెట్ నమూనా రకం మేము ఆ
ఒక లూప్ నిర్మాణంలో చాలు.
ఒక ఉదాహరణ ఎత్తు టేక్, ఎనిమిది చెప్పటానికి మీరు మొదలు ఉంటే మరియు చూడండి
ఒక నమూనా ముందుకు వచ్చారు.
మొదటి వరుస ఏడు ఖాళీలు ఉంటుంది రెండు hashes తరువాత.
రెండవ వరుసలో ఆరు ప్రదేశాలు మరియు ఉంటుంది మూడు hashes, మరియు అందువలన న వరకు
ఎనిమిదవ వరుస.
>> కానీ ఎలా మీరు ప్రాతినిధ్యం వహించే రీతిలో లేదు n వ వరుస?
కార్యక్రమాలను సమావేశం గుర్తుంచుకో సున్నా ఇండెక్స్ ఉంది.
మీరు వద్ద లెక్కింపు మొదలు అర్థం సున్నా, కాబట్టి మొదటి వరుసలో సాంకేతికంగా
రెండు పొదుగుతుంది తో వరుస సంఖ్య సున్నా, వరుస సంఖ్య మూడు hashes, వరుస ఉంది
సంఖ్య రెండు కాబట్టి తరువాత, నాలుగు hashes ఉంది ఏ వరుస కోసం ఈ నమూనా
సంఖ్య N, N ప్లస్ 2 hashes ఉన్నాయి.
నేను కనుగొనేందుకు, అయితే, మీరు చెప్పను ఖాళీలు కోసం నమూనా అవ్ట్.
మీ నమూనా గుర్తుంచుకోవాలి మీరు ఎంచుకుంటే కొద్దిగా వివిధ
మీ మొత్తం నుండి మొదలు ఒక మరియు సున్నా కాదు.
>> ఇప్పుడు, మీరు ఒక నమూనా కలిగి ఏ వియుక్త వరుస n.
మీరు అనేక ప్రదేశాలు ప్రింట్ మరియు ఎలా ఎన్ని hashes, కాబట్టి ప్రతి వరుస కోసం, ఆ
సంఖ్య మారుతుంది.
కానీ ఒక ప్రింటింగ్ అదే ప్రక్రియ ఒకే పాత్ర, ఒక స్థలం లేదా ఒక
hash, పునరావృతం అవుతుంది.
సో మీరు చెయ్యవలసింది అన్ని పదేపదే ఉంది అనేక సార్లు ఆ పాత్ర ప్రింట్
మీ నమూనా నిర్ణయిస్తుంది వంటి.
>> సో ఎలా మేము ప్రక్రియలు పునరావృతం చెయ్యాలి?
స్క్రాచ్ లో, మళ్ళీ బ్లాక్ ఉపయోగిస్తారు.
సి, మేము లూప్ ఒక ఉపయోగిస్తాము.
సింటాక్స్ చూద్దాం యొక్క ఉచ్చులు కోసం కోసం.
>> లూప్ ప్రతి మూడు కూడి ఉంటుంది భాగాలు, ఒక ప్రారంభ, ఒక పరిస్థితి,
మరియు ఒక నవీకరణ.
మీ కోసం లూప్ ప్రారంభించడం ఉంటుంది ఒక వేరియబుల్ అది మొదటి
లూప్ ప్రవేశిస్తుంది.
పరిస్థితి ఏర్పడితే, శరీరం లూప్ యొక్క అమలు అవుతుంది.
తరువాత, నవీకరణ అమలు అవుతుంది.
>> పరిస్థితి ఇప్పటికీ ఏర్పడితే, లూప్ అమలు మరియు అప్డేట్ మరియు ఉంటుంది
మీ పరిస్థితి కాలం పునరావృతం ఒప్పుకు అంచనా వేస్తుంది.
మీరు పరిస్థితి చివరకు valuate ఉండాలి ఉన్నాము ఎందుకంటే, అయితే, తప్పుగా సెట్
స్క్రాచ్ కాకుండా, మేము లేదు ఏ ఫరెవర్ ఉచ్చులు కలిగి.
మీ ప్రోగ్రామ్ చివరికి ముగియాలి.
>> ఇక్కడ ఒక ఉదాహరణ లూప్ ఆ కోసం వార్తలు మీరు మారియో కోసం వుపయోగించాలని అనుకొనుచున్న.
ప్రారంభ ప్రకటించాడు విలువ 0 తో ఒక పూర్ణాంకం i.
కాలం i ఎత్తు కంటే తక్కువగా ఉంటుంది వంటి, లూప్ యొక్క శరీరం అమలు మరియు ఉంటుంది
ఒక ద్వారా నేను పెంచడానికి మరియు పునరావృతం i కంటే ఎక్కువ లేదా వరకు
ఎత్తు సమానంగా.
>> ఇప్పుడు, నా కోసం లూప్ సున్నా సూచిక.
నేను సున్నా కాదు ఒక ప్రారంభమవుతుంది Int.
నేను ఒక ఎంచుకున్నాడు ఉంటే, అప్పుడు నా పరిస్థితి చేస్తాను కూడా వేర్వేరు ఉండాలి
అమలు లూప్ సార్లు అదే నెంబర్.
మీరు మరింత జాగ్రత్తగా ఈ గుర్తుంచుకో మీ ప్రారంభ మరియు మీ ఎంపిక
పరిస్థితి, మరియు ఈ సంప్రదించండి తనిఖీ స్థానంలో.
>> కంప్యూటర్ గురించి గొప్ప విషయాలు ఒకటి సైన్స్ కేవలం చాలా ఉంది అని
విషయాలు అమలు మార్గాలను.
మీరు ఎంచుకోవచ్చు లేదో మీరు సున్నా లేదా ఒక వద్ద మొదలు.
మీరు లూప్ ఒక ఉపయోగించడానికి అనుకుంటే, మీరు కూడా ఒక సమయంలో లూప్ ఉపయోగించవచ్చు
మీరు ఉన్నంత ప్రకటనలు పునరావృతం , లూప్ ఒక సారాన్ని ఉంచేందుకు
ప్రారంభ, పరిస్థితి, మరియు నవీకరణ.
ఒకసారి మేము లూప్ ఆ దొరుకుతుందని మేము అప్పుడు, చాలా సౌకర్యంగా ఉన్నాము మేము
మారియో పూర్తిచేయవచ్చు.
>> మేము మొదటి వినియోగదారు ఇన్పుట్ కోసం తనిఖీ ఆపై ఒక గుర్తి
ఏ వరుస n కోసం నమూనా.
కాబట్టి సున్నా నుంచి n మైనస్ 1 ప్రతి వరుస కోసం సరైన సంఖ్య ముద్రిస్తుంది
అప్పుడు ఖాళీలు, సరైన సంఖ్య మా నమూనా ప్రకారం hashes, మరియు
అప్పుడు ఒక కొత్త లైన్.
తో, మీరు మీ పిరమిడ్ కలిగి.
నా పేరు Zamyla ఉంది, మరియు ఈ మారియో ఉంది.