>> ZAMYLA Chan: Sabihin pagtalon sa Mario.
Mario ay isang programa kung saan magsasagawa kami ng aming mga sarili, kahit na noong unang panahon, na bersyon ng
isang klasikong Super Mario Brothers laro background.
Para sa set na ito problema, kami ay pagpunta upang muling likhain ang half-pyramid para sa
Mario sa tumalon sa.
Ang aming mga programa ay interactive, kaya ito hihilingin sa gumagamit na i-input ng isang tiyak na
taas para sa mga pyramid.
At ang programa ay i-print ang isang half-pyramid na ng taas, kung saan ang
ibabang kaliwa hash aligns sa ibaba kaliwang sulok ng terminal
output window.
>> Sabihin masira ang problemang ito sa dalawang bahagi, isa, kumuha ng mga user input, at dalawa,
i-print ang mga pyramid.
Tandaan na bagaman ang function na GetInt ay makuha ang isang integer, mo
mayroon upang matiyak na ang input na ito ay ginagawang saysay para sa iyong programa, kaya sa
Mario, hindi ito gawin lamang ng produkto para sa isang integer.
Kakailanganin mo upang matiyak na ang mga gumagamit input ng isang integer na nasa loob ito ng
mas mababa at itaas na hangganan ng pyramid na maaari mong i-print.
Bawat spec na ito, ito ay 0 at 23 inclusive.
Kung gumagamit ang input ng isang integer sa labas sa aming mga tinanggap na hangganan, at pagkatapos ay nais naming
upang i-prompt ang mga ito muli at muli hanggang sa sila bigyan kami ng isang wastong integer.
>> Ang isang paraan upang masiguro na ang wastong input ng user ay sa pamamagitan ng paggamit ng isang Do-Habang loop, na siyang
halos kapareho sa isang loop Habang.
Ang Do-loop Habang executes ang code sa loob ng katawan nang isang beses, at pagkatapos ay sumusuri
kung ang mga kondisyon ay nakamit o hindi.
Ito ay kapaki-pakinabang para sa pagkuha ng user input dahil alam mo na kailangan mo
upang i-prompt ang mga ito ng hindi bababa sa isang beses.
Kung ang kalagayan ay hindi natugunan, ang programa ay isakatuparan ang mga linya matapos
ang iyong Do-Habang loop.
Kung ang kondisyon ay nakilala, kahit na, loop ay ang ulitin.
>> Ang isang Do-Habang loop para sa pagpapatunay ng gumagamit input ay magmumukhang ganito.
Ipinahahayag ko sa isang variable n, GetInt, at paulit-ulit hanggang sa n ay wasto.
Tandaan na kapag ikaw ay magpahayag ng iyong variable, ito ay nangangailangan ng naaangkop na
saklaw, tulad ng sa scratch.
Kung ako magpahayag ng N sa loob ng aking Do-Habang loop, ang natitirang bahagi ng programa ay hindi magiging
ma-access ito.
Ito ay limitado sa paligid ng kulot tirante.
>> Ang lahat ng mga karapatan, kaya ngayon na napatunayan namin input ng gumagamit, namin talagang kailangan upang
gumuhit ang half-pyramid.
Binubuo ito ng mga naka-print na mga character, kaya sabihin gumawa ng isang half-pyramid sa isang simpleng
text editor.
Kung gusto naming gumawa ng isang pyramid Mario estilo ng tatlong taas na nakahanay
sa kaliwang bahagi ng aming window, at pagkatapos ay Gusto naming i-type ang dalawang hashes, i-click ang Ipasok,
pagkatapos i-type tatlong hashes, i-click ang Ipasok, at pagkatapos i-type apat.
>> Ngunit sa problemang ito hanay, ang aming half-pyramid ay kailangang karapatan nakahanay.
Gamit ang isang standard na keyboard, kung paano sa iyo upang baguhin ang file na ito upang ilipat hashes
sa ibabaw sa kanan gilid?
Maaari kong gamitin upang underscore, dalawa sa tuktok na hilera at isa sa ikalawang.
Na hindi kamukha ng maganda, bagaman, sa gayon sabihin palitan ang underscore sa
puwang, at doon kami ay may isang half-pyramid taas ng tatlo.
>> Subukan at tandaan ito text editor Halimbawa bilang simulan mo ang pag-iisip pabalik sa
C. natin subukan at malaman kung ilan uri ng mga pattern na aming makakaya
ilagay sa isang bumuo ng mga loop.
Dumaan isang halimbawa taas, sabihin walong, at tingnan kung maaari mong simulan upang
makabuo ng isang pattern.
Ang unang hilera ay magkakaroon ng pitong mga puwang sinundan ng dalawang hashes.
Ang ikalawang hanay ay may anim na mga puwang at tatlong hashes, at iba pa hanggang sa ang
pangwalo hilera.
>> Ngunit paano nais mong kumatawan ang nth hilera?
Tandaan na ang programming convention ay zero-index.
Nangangahulugan iyon na simulan mo ang pagbibilang sa zero, kaya ang unang hilera ay technically
hilera bilang zero na may dalawang hatches, hilera bilang isa ay may tatlong hashes, hilera
dalawang numero ay may apat na hashes, kaya pagsunod ang pattern na ito para sa anumang hilera
bilang n, may mga n plus 2 hashes.
Makikita ko bang iwan ito sa iyo, bagaman, upang mahanap ang out ang pattern para sa mga puwang.
Tandaan na ang iyong pattern ay magiging bahagyang naiiba kung pinili mong
simulan ang iyong count mula sa isa at hindi zero.
>> Ngayon, mayroon kang isang pattern para sa anumang abstract n hilera.
Alam mo kung gaano karaming mga puwang upang i-print at kung gaano karaming mga hashes, kaya para sa bawat hilera, na
numero ay magbabago.
Ngunit ang parehong proseso ng pag-print ng isang solong character, alinman sa isang puwang o isang
hash, ay paulit-ulit.
Kaya ang kailangan mo lang gawin ay ang paulit-ulit i-print na karakter para sa maraming beses
bilang iyong pattern tinutukoy.
>> Kaya paano namin ulitin ang proseso?
Sa simula, ginamit namin ang umuulit na bloke.
Sa C, gagamitin namin ang isang Para sa loop.
Tignan natin ang syntax para sa Para sa mga loop.
>> Para sa bawat loop ay binubuo ng tatlong mga bahagi, isang Pinasimulan, isang kondisyon,
at isang pag-update.
Ang iyong Para sa loop ay initialize isang variable kapag ito unang
pumasok ang Para sa loop.
Kung ang kondisyon ay nakilala, ang katawan ng mga loop ay isakatuparan.
Pagkatapos, ang update execute.
>> Kung ang kalagayan ay pa rin nakilala, ang loop ay execute at i-update at
ulitin hangga't iyong mga kondisyon sinusuri sa True.
Ikaw ay dapat kondisyon kalaunan valuate sa False, bagaman, dahil
hindi katulad sa simula, hindi kami magkakaroon ng anumang mga loop Habang Panahon.
Ang iyong programa ay dapat magtapos sa huli.
>> Narito ang isang halimbawa ng isang Para sa loop na baka gusto mong gamitin para sa Mario.
Pinasimulan Ang declares isang integer i may halagang 0.
Hangga't i ay mas mababa sa taas, katawan ng loop ay execute at
i taasan sa pamamagitan ng isa at ulitin hanggang sa i ay mas malaki kaysa sa o
katumbas ng taas.
>> Ngayon, ang aking Para sa loop ay zero index.
Ang int i nagsimula sa zero, hindi isa.
Kung pinili ko ang isa, at pagkatapos ay ang aking kondisyon ng ginagawa Mayroon din na maging magkaiba para sa
ang loop upang isakatuparan ang parehong bilang ng beses.
Tandaan ang maingat kapag ikaw ay pagpili ng iyong Pinasimulan at ang iyong
kalagayan, at kumonsulta ito tsart upang i-double check.
>> Isa sa mga dakilang bagay tungkol sa computer na agham ay mayroong lamang kaya maraming mga
mga paraan upang isakatuparan bagay.
Maaari mong piliin kung ikaw Magsisimula sa zero o isa.
Kung hindi mo nais na gumamit ng isang Para sa loop, maaari mo ring gamitin ang isang Habang loop upang
ulitin ang mga pahayag hangga't mo panatilihin ang kakanyahan ng isang Para sa loop,
Pinasimulan, kundisyon, at pag-update.
Sa sandaling namin malaman ang Para sa loop na kami ay pinaka-maginhawa para sa iyo, pagkatapos namin
Maaari makumpleto Mario.
>> Kami unang naka-check para sa mga gumagamit ng pag-input at pagkatapos ay nakilala ang isang
pattern para sa anumang n hilera.
Kaya para sa bawat hilera mula sa zero n minus 1 ay i-print ang naaangkop na bilang ng mga
puwang, pagkatapos ay ang naaangkop na bilang ng mga hashes ayon sa aming mga pattern, at
pagkatapos ng isang bagong linya.
Gamit na, mayroon kang ang iyong mga pyramid.
Ang pangalan ko ay Zamyla, at ito ay Mario.