Nilalaman

• yugto
• Bahagi 1 Lumikha ng isang algorithm
• Bahagi 2 Lumikha ng isang algorithm ng koneksyon

Sa artikulong ito: Lumilikha ng isang algorithmMaghangad ng isang algorithm ng koneksyon

Ang isang algorithm ng programming ay ang intermediate na hakbang sa pagitan ng pagbabasa ng mga pagtutukoy ng isang application ng software at pag-cod ng iba't ibang mga bahagi ng programa na gagawing tumakbo. Kadalasan maraming mga paraan upang makarating sa parehong layunin at ito ay sa panahon ng disenyo ng algorithm na kami ay bubuo kasama ang pinakadakilang posibleng katumpakan ang pinaka-epektibong paraan upang sundin upang makarating doon. Ang yugtong ito ng programming ay samakatuwid ay isang mahalagang paunang sa anumang form ng programming.

yugto

Bahagi 1 Lumikha ng isang algorithm

1. Ang isang algorithm ay ang paghahati sa mga hakbang ng isang kumplikadong pamamaraan. Sa parehong paraan na nagdidisenyo ka ng isang ruta sa kalsada, posible na masira ang lahat ng mga elemento ng isang application ng computer, kahit na sobrang kumplikado, sa maliit na mga sub-programa na magiging mas madaling pamahalaan at pagsamahin sa isa't isa mamaya.

2. 
   

   
   Isama ang isang diskarte sa syntax na gagamitin. Ito ay depende sa mahalagang wika sa programming language na gagamitin mo.

3. 
   

   
   Simulan ang paglalagay ng iyong algorithm sa papel.

4. 
   

   
   
   
   Isama ang mga variable sa pamamagitan ng pagpapaliwanag ng kanilang papel. Ang mga variable ay dapat nasa isang bloke ng mga pagpapahayag sa simula ng programa kung sila ay pandaigdigan o subroutine kung sila ay lokal. Ang pangalang itinalaga mo sa kanila ay dapat na katangian ng kanilang kinakatawan at ang mga nilalaman nito ay dapat tumutugma sa isang uri ng data na tinatanggap ng wikang iyong gagamitin.

5. 
   

   
   Magtatag ng isang counter counter. Kung gumagamit ka ng mga loop sa iyong algorithm, mag-set up ng isang sistema ng pagbibilang ng mga pagpapatupad ng loop upang malaman kung ilang beses na tinawag ang mga nakagawiang ito.

6. 
   

   
   Magtalaga ng isang loop-out point sa iyong algorithm. Ang isang loop-out point ay dapat italaga kung ang isang kondisyon ay natutugunan, ngunit planuhin ang isa na nagpapahintulot sa isang "malinis" na output ng loop kung ang kundisyong ito ay nawawala. Ginagawa nitong posible na huwag magpasok ng mga loop na huling walang hanggan.

7. 
   

   
   
   
   Maingat na gumamit ng jump control. Ang mga jumps sa pagitan ng mga subroutines ay maaaring maging kondisyon o walang kondisyon.

8. 
   

   
   Iwasan ang pagpasok ng mga hindi natukoy na data sa algorithm. Kung ang impormasyon na maiproseso ay dapat na maidagdag "en ruta" (ito ang nangyayari nang madalas kahit sa mga pros), idagdag ang mga ito sa block ng kahulugan ng data ng iyong algorithm.

9. 
   

   
   Tukuyin nang tama ang iyong mga expression, kondisyon o hindi. Ang mga expression na ito ay tumutugma sa pagpapatupad ng mga pormula ng lohika o kung minsan matematiko, na umangkop ka sa mga detalye ng iyong aplikasyon. Mahalaga ito upang maiwasan ang mga pagkakamali sa antas na ito.

10. 
    

    
    Ilagay ang mga puntos ng break at itigil ang pagpapatupad ng pamamaraan. Ang isang pahinga ay nagbibigay-daan sa iyo upang lumabas ng isang loop kapag nakatagpo ang isang kondisyon at magpatuloy sa pagpapatupad sa ibang lugar, habang ang isang paghinto ay karaniwang nagtatapos (pansamantala o hindi) ang pagpapatupad ng isang programa.

Bahagi 2 Lumikha ng isang algorithm ng koneksyon

1. 
   

   
   Lumikha ng isang pag-login para sa gumagamit.

2. 
   

   
   Suriin ang pangalan ng gumagamit at password. Ihambing ang iyong algorithm sa data na ipinasok ng gumagamit sa mga nilalaman ng database na nakalaan para sa data ng pahintulot sa pag-access.

3. 
   

   
   Pahintulutan ang simula ng sesyon kung ang mga data na ito ay may bisa. I-redirect ang programa sa isang entry point para sa gumagamit na iyon.

4. 
   

   
   Ipagbigay-alam sa gumagamit kung ang data ay naipasok ay hindi wasto. Mag-snap ng isang chess counter at pagkatapos ay i-redirect ang programa sa pagpapakita ng impormasyon at payagan ang dalawa o tatlong mga pagtatangka sa koneksyon. Kung nabigo silang lahat, itigil ang programa nang ilang sandali bago pinahihintulutan ulit ang gumagamit na ito. Ito ay mawawalan ng pag-asa o hindi bababa sa isang pagtatangka upang pilitin ang pag-access sa system na iyong dinisenyo.

5. 
   

   
   Lumabas ng malinis sa programa. Ang data na maiimbak bago iwanan ang iyong aplikasyon ay dapat na tama. Kung hindi, maaari silang masira at maiwasan ang isang tamang pag-restart ng iyong programa.

payo

• Tanggalin ang mga hindi kinakailangang mga puna, dahil maaari silang makaapekto sa pag-unawa sa iyong algorithm.
• Gumamit ng mga patakaran ng dalawang-estado na lohika (o lohika ng Boolean) na maaaring makita ng isang computer at tugon sa kanila. Walang "siguro" sa programming, ito ay palaging "oo o hindi".
• Gumamit ng simpleng mga iterasyon at mabilis na pagpapatupad.
• Palaging subukan na dumiretso sa puntong.
• Ang iyong algorithm ay dapat maging epektibo.
• Bago simulan ang isang algorithm, magkaroon ng malinaw na mga ideya tungkol sa nais mong gawin.

babala

• Tandaan na isaalang-alang ang mga oras ng pagpapatupad at pamamahala ng memorya. Nalalapat ito lalo na kung ikaw ay nagprograma sa mga naka-embed na system na may limitadong mga mapagkukunan ng memorya.
• Tapusin nang maayos ang iyong programa.