**Pseudokood** on mitteametlik kõrgtasemeline arvutiprogrammi või algoritmi tööpõhimõtte kirjeldus.

Pseudokoodis kasutatakse normaalse programmeerimiskeele struktuuri, aga selle põhiline eesmärk on olla loetav inimeste, mitte masina jaoks. Tüüpiliselt ei sisalda pseudokood detaile, mida masin vajab algoritmi mõistmiseks, näiteks muutujate deklaratsioonid, süsteemispetsiifilised koodiread ning alamprogrammid. Programmeerimiskeelele lisatakse vajadusel kirjeldusi loomulikus keeles või kompaktses matemaatilises kirjaviisis. Pseudokoodi eesmärk on lihtsal viisil inimestele seletada, kuidas kood töötab. See on palju tõhusam ja keskkonnast sõltumatu kirjeldus algoritmi tööpõhimõttest. Seda kasutatakse sagedasti õpikutes ja teaduslikes väljaannetes, mis dokumenteerivad algoritme. Samuti ka arvutiprogrammide arendamises, kus visandatakse valmis programmi struktuur enne programmeerimise alustamist.

Pseudokoodi süntaksil puudub igasugune standard, kuna pseudokoodis programmi ei saa käitada. Pseudokood sarnaneb, aga ei tohi eksitada luukere programmeerimisega, mis kompileerub ilma veateadeteta. Voodiagrammid, drakon-diagrammid ja ühtse modelleerimiskeele diagramme saab vaadata kui graafilisi alternatiive pseudokoodile, aga need nõuavad rohkem ruumi paberi peal. Programmeerimiskeel HAGGIS kujutab endast ühendavat silda pseudokoodi ja teiste programmeerimiskeelte vahel.

Rakendus
--------

Arvutiteaduse ja numbrilise arvutamisega seotud õpikud ja teaduslikud väljaanded kasutavad tihtipeale algoritmide kirjeldamisel pseudokoodi nii, et programmeerijad saavad neist aru isegi kui nad ei tunne kõiki programmeerimiskeeli. Tüüpiliselt seletatakse õpikutes lahti, kuidas kasutatud pseudokoodist aru saada. Pseudokoodi detailitase võib kohati sarnaneda tavakeele omaga.

Programmeerijad, kes hakkavad tundmatut algoritmi programmeerima, alustavad tihtipeale algoritmi kirjeldamisega pseudokoodis ja alles siis "tõlgivad" selle kirjelduse vastavasse programmeerimiskeelde ning muudavad seda nii, et see töötaks ülejäänud programmiga. Samuti võivad programmeerijad alustada projektiga, visandades koodi pseudokoodis paberi peale enne tegelikule programmeerimiskeelele üle minemisele. Seda nimetatakse top-down struktuuriliseks lähenemiseks.

Süntaks
-------

Nagu nimigi ütleb, siis pseudokood tüüpiliselt ei jälgi teiste programmeerimiskeelte süntaksi reegleid. Süstemaatiline standardne kuju puudub, kuigi ükskõik milline kirjutaja üldiselt kasutab mingit stiili või süntaksit (näiteks mõne traditsioonilise programmeerimiskeele kontrollistruktuure). Populaarsemate süntaksite alla kuuluvad: Fortran, Pascal, BASIC, C, C++, Java, Lisp ja ALGOL. Muutujate deklaratsioonid jäetakse enamasti välja. Funktsioonide väljakutsmised ning koodiblokid (näiteks koodiread, mis sisaldavad tsükleid) asendatakse enamasti üherealise lausega loomikus keeles.

Olenevalt kirjutajast võib pseudokood stiili poolest laialt varieeruda: päris programmeerimiskeeles kirjutatud ridadest kuni kirjelduseni, mis sarnaneb vormindatud proosaga.

Allpool on mõned näited pseudokoodist (matemaatilisele mängule fizz buzz):

|  |  |  |  |
| --- | --- | --- | --- |
| Fortan stiilis pseudokood

```
program fizzbuzz
 Do i = 1 to 100 
 set print\_number to true
 If i is divisible by 3
 print "Fizz"
 set print\_number to false
 If i is divisible by 5
 print "Buzz" 
 set print\_number to false
 If print\_number, print i
 print a newline
 end do

```
 | Pascali stiilis pseudokood

```
procedure fizzbuzz
  For i := 1 to 100 do
    set print\_number to true;
    If i is divisible by 3 then
      print "Fizz";
      set print\_number to false;
    If i is divisible by 5 then
      print "Buzz";
      set print\_number to false;
    If print\_number, print i;
    print a newline;
  end

```
 | C stiilis pseudokood:

```
void function fizzbuzz {
 for (i = 1; i <= 100; i++) {
 set print\_number to true;
 If i is divisible by 3 {
 print "Fizz";
 set print\_number to false; }
 If i is divisible by 5 {
 print "Buzz";
 set print\_number to false; }
 If print\_number, print i;
 print a newline;
 }
}

```
 | Struktureerid Basic stiilis pseudokood

```
Sub fizzbuzz()
 For i = 1 to 100
 print\_number = True
 If i is divisible by 3 then
 print "Fizz"
 print\_number = False
 End If
 If i is divisible by 5 then
 print "Buzz"
 print\_number = False
 End If
 If print\_number = True Then print i
 Print a newline
 Next i
End Sub

```
 |

Matemaatilises stiilis pseudokood
---------------------------------

Numbrilises arvutuses pseudokood sisaldab tihti matemaatilist kirjaviisi, mis on tüüpiliselt saadud hulga- ja maatriksiteooriast, millesse on lisatud mõne tavapärase programmeerimiskeele kontrollstruktuurid ja vahel ka kirjeldus loomulikus keeles. See on kompaktne ja üldiselt mitteametlik kirjaviis, millest võivad aru saada paljud matemaatikud, ja on tihti kasutatud ühe viisina matemaatiliste algoritmide lahti seletamiseks. Näiteks summa tehetemärki või korrutuse tehetemärki võib kasutada *for*-tsüklina ja valitud struktuurina ühes väljendis:

```
Return {\displaystyle \sum \_{k\in S}x\_{k}}
```

Matemaatiliste tehete kirjutamisel kasutatakse üldiselt mitte-ASCII ladumist (näiteks märgendus keeltes nagu TeX, MathML või kinnistes valemi redaktorites.

Matemaatilises stiilis pseudokoodi on mõnikord nimetatud ka pidžinkoodiks. Näiteks "pidžin ALGOL" (mõiste päritolu), "pidžin Fortran", "pidžin BASIC", "pidžin Pascal", "pidžin C" ja "pidžin Lisp".

### Tihtiesinevad matemaatilised sümbolid


| Operatsiooni tüüp | Sümbol | Näide |
| --- | --- | --- |
| Määramine | ← or := | `*c* ← 2π*r*`, `*c* := 2π*r*` |
| Võrdlemine | =, ≠, <, >, ≤, ≥ |  |
| Aritmeetika | +, −, ×, /, mod |  |
| Üles/alla ümardamine | ⌊, ⌋, ⌈, ⌉ | `*a* ← ⌊*b*⌋ + ⌈*c*⌉` |
| Loogika | **and**, **or** |  |
| Summad, Korrutised | Σ Π | `*h* ← Σ*a*∈*A* 1/*a*` |

### Näide

Allpool on pikem näide matemaatilises stiilis pseudokoodist Ford-Fulkerson algoritmist:

```
**algorithm** ford-fulkerson **is**
    **input:** Graph *G* with flow capacity *c*, 
           source node *s*, 
           sink node *t*
    **output:** Flow *f* such that *f* is maximal from *s* to *t*

    *(f(u,v) on voog sõlmkohast u kuni sõlmkohani v ja c(u,v) on voo maht sõlmkohast u kuni sõlmkohani v)*

    **for each** edge (*u*, *v*) **in** *G**E* **do**
        *f*(*u*, *v*) ← 0
        *f*(*v*, *u*) ← 0

    **while** there exists a path *p* from *s* to *t* **in** the residual network *G**f* **do**
        let *c**f* be the flow capacity of the residual network *G**f*
        *c**f*(*p*) ← min{*c**f*(*u*, *v*) | (*u*, *v*) **in** *p*}
        **for each** edge (*u*, *v*) **in** *p* **do**
            *f*(*u*, *v*) ← *f*(*u*, *v*) + *c**f*(*p*)
            *f*(*v*, *u*) ← −*f*(*u*, *v*)

    **return** *f*
```

Pseudokoodi stiilis keelte kompileerimine
-----------------------------------------

### Loomuliku keele grammatika programmeerimiskeeltes

Katsetega on üritatud tuua loomuliku keele grammatika elemendid arvutiprogrammeerimisse, tänu millele on loodud sellised programmeerimiskeeled nagu HyperTalk, Lingo, AppleScript, SQL, Inform ja vähemal määral ka Python. Nendes keeltes on ümarsulud ja muud erimärgid asendatud eesõnadega, mistõttu on kood väga "jutukas". Neid keeli kirjutatakse üldiselt dünaamiliselt, mis tähendab, et muutujate väljakutsumised ja muud korduvad read saab välja jätta. Sellised keeled teevad elu lihtsamaks nendel inimestel, kes ei saa antud programmeerimiskeelest aru ning soovivad seda omandada. Sarnasus loomuliku keelega on siiski pigem tehislik. Süntaksireeglid võivad olla sama ranged ja ametlikud kui traditsioonilises programmeerimises ja see ei tee programmide arendamise sugugi kergeks.

### Matemaatilised programmeerimiskeeled

Pseudokoodi kasutamise alternatiiviks (mis sisaldab hulgateooriat või maatriksi operatsioone) algoritmide dokumenteerimisel on ametlike matemaatiliste programmeerimiskeelte kasutamine, mis on segu mitte-ASCII matemaatilisest kirjaviisist ja programmi kontrollstruktuurist.

Mitmed ametlikud spetsifikatsioonikeeled sisaldavad hulgateooria kirjaviise kasutades erimärke. Näiteks:

* Z kirjaviis
* Vienna Arendamise Meetod

Mõned massiivi programmeerimiskeeled sisaldavad vektoriseeritud avaldusi ja maatriksi operatsioone nagu mitte-ASCII valemid, mis kasutavad traditsioonilisi kontrollistruktuure. Näiteks:

* APL ja selle programmeerimiskeele dialektid APLX ja A+
* MathCAD

Viited
------

* Zobel, Justin (2013). "Algorithms". *Writing for Computer Science* (Second ed.). Springer. ISBN 1-85233-802-4.