ZAMYLA CHAN: Ito ay isang-me, Zamyla.
Ngayon, kami ay pagpunta upang ipatupad Mario, kung saan namin gumuhit Mario
isang buong pyramid para sa kanya upang tumalon sa ibabaw.
ni masira ang Let sub-gawain para sa problemang ito.
>> Una, gusto naming upang i-prompt ang user para sa taas ng pyramid.
At pagkatapos ay nais naming tiyakin na na input ay may-bisa.
At pagkatapos ay kami ay pagpunta sa nais na gumuhit ng pyramid.
>> Kaya sabihin makipag-usap tungkol pagdikta at pagpapatunay user input.
Maaaring magmukhang parang ito, ang isang do-habang loop na
senyales ng gumagamit para sa isang integer at pagkatapos lamang repeats
kung na integer ay hindi wasto.
Kaya ano ang dapat kondisyon na ito ay?
>> Para sa, sabihin bumalik sa mga detalye.
Well, ang spec ay nagsasabi sa amin na ang anumang mga wastong taas ay pagpunta sa maging sa pagitan ng 0 at 23,
inclusive.
Kaya pagkatapos na nangangahulugan na ang anumang di-wasto taas ay pagpunta sa maging mas mababa kaysa sa 0
o higit sa 23.
>> Kaya ngayon na kami ay may impormasyon na ito, sabihin disenyo ng aming kalagayan.
Ngunit kailangan namin upang mag-ingat, dahil ngayon kami ay may
dalawang Booleans na gusto naming suriin.
>> Here I ibinigay na sa iyo may katotohanan table.
Ito ay nagpapahintulot sa amin upang magsagawa ng dalawang Booleans, Boolean isa at dalawa.
At maaari naming pag-aralan mag bool1 at bool2 o bool1 o bool2.
>> Kaya ano ang mga pagkakaiba sa pagitan ng at at o?
Well, bool1 at bool2 habilin suriin sa tunay at kung lamang
kung ang parehong Booleans ay totoo, samantalang ang o operasyon
ay magiging totoo kung alinman sa isa sa ang Booleans o pareho ay totoo.
Kaya sa mga ito sa isip, tingnan kung maaari mong malaman kung
kung ano ang naaangkop na kondisyon para sa iyong gawin-habang loop para sa isang di-wastong n
ay magiging.
>> Gamit na, na-prompt kami at napatunayan ng gumagamit para sa ang taas ng pyramid
na gusto nila.
Kaya ngayon, ikaw ang bahala sa amin upang gumuhit ng pyramid.
Ang buong pyramid para sa mga ito problema ang magiging hitsura nang kaunti
tulad nito, kung saan mayroon kaming isang kaliwa pyramid, ilang puwang, at pagkatapos ay isang karapatan pyramid.
Kaya sabihin break na ito pababa ng kaunti bit.
>> Kung pupunta ako sa aking text editor, dito na ako iguguhit sa amin ng isang kaliwa-hile-hilera pyramid.
Ngunit iyon ay hindi gawin.
Ano ang gusto naming gawin ay gusto naming lumikha ng isang right-nakahanay pyramid muna.
Kaya upang gawin ito, sa makatarungan itulak aking hashes kasama sa gilid,
Tingin lang ako sa pagpunta sa ilagay ang ilang mga character sa pagitan, lamang ang mga tuldok.
Pagkatapos ako pagpunta sa ilagay ang dalawang sa susunod na linya, at isa sa na linya.
At kaya dito mayroon akong isang right-nakahanay pyramid.
>> Pagkatapos nito, ako pagpunta sa bumalik sa tuktok na hilera
at ilagay sa ang puwang, na kung saan ay, bawat ang spec, dalawang mga puwang.
Pagkatapos ay ako pagpunta upang punan ang kabilang bahagi ng pyramid.
Pupunta ako sa pumunta sa pangalawang hilera, isulat dalawang mga puwang para sa mga puwang at pagkatapos ng dalawang
hashes.
Bumalik sa ang ikatlong hanay, dalawang mga puwang para sa mga puwang at tatlong hashes.
At sa dulo, dalawang mga puwang para sa mga puwang at apat hashes.
Kaya na kung ano ang isang buong pyramid ay ang hitsura.
>> Of course, hindi namin nais mga tuldok sa paraan.
Kaya kami ay pagpunta sa palitan ang mga mga tuldok sa pamamagitan ng paglagay ng ilang mga puwang sa.
Isa, dalawa, tatlo sa unang linya.
Isa, dalawa sa ikalawang.
At isa sa ikatlong linya.
Kaya ito ay kung ano ang nais nating gawin kung nais na lamang gumawa ng isang buong pyramid,
sabihin, sa aming text editor.
>> Kaya ipaalam sa tumagal ito, pag-unawa sa mga pattern,
at i-convert ito sa paglipas ng sa ilang pseudocode.
Para sa bawat hilera ng pyramid, nais naming upang i-print sa kaliwa pyramid at pagkatapos ay
ang puwang at pagkatapos ay sa kanang pyramid.
Para sa kaliwang pyramid, i-print namin ang kinakailangang halaga ng mga puwang,
kasunod ang hashes.
Pagkatapos i-print namin ang puwang, na kung saan ay lamang ng dalawang mga puwang sa bawat oras.
At sa tamang pyramid, i-print namin ang kinakailangang bilang ng mga hashes.
>> Para sa ikalawang hilera, na isinasagawa namin ang parehong eksaktong proseso.
I-print namin ang mga puwang para sa kaliwa pyramid, ang kinakailangang halaga
ng hashes, ang puwang, dalawang mga puwang, at pagkatapos ay ang hashes para sa mga karapatan pyramid.
>> ni harapin ang mga pattern Hayaan para sa kaliwa pyramid.
Kung ako ay, para sa mga layunin ng halimbawang ito, isang taas
ng walong hiniling ng user, pagkatapos ay ang aking unang hanay
ay magkakaroon ng isa hash at pitong mga puwang.
Aking ikalawang hanay ay may dalawang hashes, anim na mga puwang.
Ikatlong hanay, ay tatlong hashes, limang mga puwang.
Maaari mong marahil gawin ito ang iyong sarili para sa isang taas ng walong
at matukoy para sa bawat hilera kung gaano karaming hashes at kung gaano karaming mga puwang na kailangan mo.
Ngunit kung ano ang gusto naming gawin ay gusto naming abstract ito.
Kaya hinihiling ko sa iyo para sa anumang nth hilera, kung gaano karaming mga hashes at kung gaano karaming mga puwang ang kailangan natin?
>> Ngayon, tulad ng sa iyo na matukoy ang pattern para sa kung gaano karaming mga hashes
at kung gaano karaming mga puwang na kailangan mo para anumang nth hilera para sa isang naibigay taas,
tandaan na maging maingat ng kung paano ka na-index.
Ano ang ibig sabihin ko sa pamamagitan ng ito ay na sa araw-araw buhay karamihan sa atin magbilangan-isa.
Kaya ang unang hilera ay magiging bilang isa.
At ang ikalawang hanay ay magiging hilera bilang dalawang, iba pa at iba pa.
>> Ngunit sa computer science at CS50, kami ay zero-index.
Kaya namin talagang simulan ang pagbibilang sa zero.
Kaya ang unang hilera ng gagawin maging row number zero.
At ang ikalawang hanay ay magiging hilera bilang isa.
Kaya kung ako ay nagkaroon ng isang taas ng walong para aking pyramid, pagkatapos ay ang huling halaga ng n
ay tunay na maging pitong at hindi walo.
>> Kaya mag-ingat tungkol dito.
At magkaroon ng kamalayan kapag kayo ay pagtukoy ang iyong pattern kung ang iyong zero-index
o isang-index
>> OK.
Kaya ngayon na kami ay may mga pattern para sa kaliwa pyramid,
kailangan namin upang matukoy ang pattern para sa puwang.
Sa kabutihang-palad, ito ay talagang madali.
Ito ay lamang ng palaging dalawang mga puwang.
>> Kaya ngayon kami ay magpatuloy sa kanan pattern.
Ang unang hanay ay magkakaroon ng isa hash.
Ang ikalawang hanay, ay dalawa.
Ikatlong hanay, ay tatlo.
Iba pa at iba pa.
Kaya muli, matukoy para sa anumang abstract n at anumang taas kung gaano karaming mga hashes
at kung gaano karaming mga puwang bawat hilera ay dapat magkaroon.
>> OK.
Kaya alam namin na para sa bawat hilera namin kailangan upang magsagawa ng ilang mga proseso.
Paano namin gawin iyon?
Well, kami ay gumagamit ng para sa loop ay makagawa, binubuo ng isang initialization,
isang kondisyon, at isang pag-update.
Para sa mga loop ay maaaring gamitin upang ulitin proseso.
>> Kaya sinasabi Gusto ko ito upang kamustahin, mundo 50 beses, pagkatapos ay ang aking para sa loop
magiging hitsura ng isang bagay tulad nito, kung saan magpasimula ko ang aking variable sa zero.
Ang kalagayan ay na ako ay mas mababa sa 50.
At pagkatapos ay ang update ay na ito palugit sa pamamagitan ng isa sa bawat oras.
Kaya kung ano ito ay gawin ay upang i-print kumusta, mundo 50 beses sa isang hilera.
>> Ngayon, sinasabi ko nais na umulit sa ibabaw ng taas ng pyramid.
Pagkatapos ay sa halip ng matapang na coding ilang mga halaga sa ang mga kondisyon,
Ko na lang gamitin ang mga variable taas.
Kaya kung ano ito ay gawin ay umulit sa ibabaw ng taas ng bawat hilera.
At maaari kong gawin ang isang bagay sa loob ng katawan ng na loop.
>> Ano ang gusto naming gawin sa loob ng katawan ng loop?
Well, bilang namin na ipinahiwatig bago, gusto naming upang i-print ang mga puwang at ang hashes
para sa kaliwa pyramid at pagkatapos ay i-print dalawang mga puwang at pagkatapos ay i-print ang hashes.
Kaya ko na may korte namin na out.
Upang maaari naming simulan upang punan sa aming programa ng maraming mas.
>> Narito Mayroon akong isang panlabas na para sa loop na iterates sa paglipas ng bawat hilera sa pyramid.
At sa loob ng katawan na pupuntahan ko upang i-print puwang paulit-ulit,
hashes paulit-ulit, at pagkatapos ay ang puwang, at pagkatapos ay hashes para sa mga karapatan pyramid,
at pagkatapos, sa wakas, ang isang bagong linya upang simulan ang susunod na hilera.
>> Gamit na, na-prompt kami ang user para sa input.
Gumawa kami sigurado na ito ay may-bisa.
At pagkatapos ay inilabas na namin ang pyramid.
Kaya Mario Maaari matagumpay umakyat ang pyramid.
>> Ang pangalan ko ay Zamyla.
At ito ay CS50.