## Krestomatiaj algoritmoj

1. La Eratostena kribrilo: en Paskalo
2. Ekzempla senkondiĉa iteracio: funkcio «prima» en MODULA
3. La Hanojaj turoj: en Paskalo
4. kopiuTekston: Programo kun ingita iteracio
5. Faktorialoj: rikure iteracia kaj rekursia realigoj
6. Duoniga serĉo en Paskalo
7. La bobelmetoda ordigo: en Paskalo
8. La Rapida ordigo: en Paskalo
9. Vektora stako: Realigo en Paskalo, per vektoro
10. La Nederlanda standardo: en Paskalo
11. La 8 damoj: en Paskalo
12. Ekzemplo pri rekursia desupriĝo: en Paskalo
13. La piramida ordigo: en Paskalo
14. Larĝiĝema trairo de grafeo: en Paskalo
15. Profundiĝema trairo de grafeo: en Paskalo
16. Simpla stokastogenerilo: en Paskalo
17. Pli ĝenerala stokastogenerilo: en MODULA
18. La dormema frizisto: en MODULA
19. La 5 filozofoj: en Ada

### La Eratostena kribrilo en Paskalo

    VAR prima: TABELO [1 .. n] EL Bulea;
        baro, i, j: entjera;
    STARTO
      baro := trunko(rad(n));          {-- supera baro por la analizo}
      POR i := 2 SUPRE n FARU prima[i] := vero;    {-- komencvalorizo}
      prima[1] := malvero;                            {-- "forstreku" 1}
      POR i := 2 SUPRE baro FARU
        SE prima[i] TIAM STARTO
          j := i + i;
          DUM j ≤ n FARU STARTO
            prima[j] := malvero;
            j := j + i;
          FINO;
        FINO;
      POR i := 2 SUPRE n FARU SE prima[i] TIAM skribu(i);
    FINO.

### Ekzempla senkondiĉa iteracio kun revenordonoj

Ĉi tiu funkcio testas, ĉu ĝia parametro estas prima. Ĝi aspektas idente em MODULA-2 kaj en Oberono.

       PROCEDURO prima(VAR n:entjera): Bulea; (*ĉu n estas primo?*)
          VAR divizoro: entjera;
       STARTO
          SE n MOD 2 = 0 TIAM REEN n = 2 FINO;
          divizoro := 3;
          MAŜO      (* --- komenciĝas senkondiĉa iteracio --- *)
             SE divizoro * divizoro > n TIAM REEN vero FINO;
             SE n MOD divizoro = 0 TIAM REEN malvero FINO;
             divizoro := divizoro + 2
          FINO      (* --- de senkondiĉa iteracio *)
       FINO

### La Hanojaj turoj en Paskalo

    PROCEDURO Hanojo(n: entjera; fS, cS, hS: signa);
       STARTO
          SE n > 0 TIAM STARTO
             Hanojo(n - 1, fS, hS, cS);
             skribuLin('la supran diskon de', fS, 'metu al', cS);
             Hanojo(n - 1, hS, cS, fS);
          FINO;       {de la SEo}
       FINO;          {de Hanojo}

    {Ekzempla voko:}      Hanojo(4, 'F', 'C', 'H');

### Programo entenanta ingitan iteracion

    PROGRAMO kopiuTekston(enigo, eligo);
    STARTO
      DUM NE doFin(enigo) FARU STARTO
        DUM NE liFin(enigo) FARU STARTO {--- la ingita iteracio:}
          eligo↑ := enigo↑;
          metu(eligo);
          prenu(enigo);
        FINO;    {--- de la ingita iteracio}
        leguLin(enigo);
        skribuLin(eligo);
      FINO       {--- de la ekstera iteracio}
    FINO.

### Faktorialoj: rikure iteracia (`f`) kaj rekursia (`F`) realigoj

    FUNKCIO f(n: entjera): entjera; | FUNKCIO F(n: entjera): entjera;
      VAR  i, r: entjera;           | STARTO
    STARTO                          |    SE n > 1 TIAM
      r := 1;                       |        F := n * F(n - 1)
      POR i:=1 SUPRE n FARU r:=r*i; |    ALIE F := 1
      f := r;                       | FINO; { de la rekursia realigo }
    FINO; { de la rikura realigo }  |

### Duoniga serĉo en Paskalo

    KONST fiasko = -1;   {uzota ekstere (Esceptoj)}
          maks  = 100;   {maksimuma longo de la tabelo}

    TIPO  indico = 1..maks;
          ĉeno   = PAKITA TABELO [1..20] EL signa;
          ano    = RIKORDO ŝlosilo: entjera; valoro: ĉeno FINO;

    FUNKCIO serĉo( VAR v: TABELO [sb..sp:indico] EL ano
                 ; ŝ: entjera
                 ):  entjera;
       { liveras la indicon en n-elementa vektoro v de ano kun ŝlosilo ŝ }
       MARKO 9;
       VAR   sube, meze, supre: indico;
             ŝm: entjera;
       STARTO sube := sb; supre := sp;
          DUM sube ≤ supre FARU STARTO
            meze := (sube + supre) DIV 2;
            ŝm := v[meze].ŝlosilo;
            SE ŝ = ŝm TIAM STARTO serĉo := meze; AL 9 FINO;
            SE ŝ < ŝm TIAM supre := ant(meze) ALIE sube := sek(meze);
          FINO;
          serĉo := fiasko;
    9: FINO {de serĉo}

### La bobelmetoda ordigo en Paskalo

       VAR v: TABELO [1 .. n] EL entjera;
           i, j: entjera;
       POR j := n - 1 SUBE 1 FARU
          POR i := 1 SUPRE j FARU
             SE v[i] › v[i + 1] TIAM permutu(v[i], v[i + 1]);

### La Rapida ordigo en Paskalo

Ĉi tiu ekzempla realigo estas verkita tiel, ke ĝi ne dependu je la strukturo de la ordigata objekto (ekz-e je la tipo de ties elementoj); tiuj detaloj estas precizendaj per la du lastaj parametroj.

    PROCEDURO rapid ( unua,lasta: entjera  {la indiclimoj de subdivido}
                    ; funkcio ordas(i,j:entjera):Bulea {ĉu x[i]≤x[j]?}
                    ; proceduro permutu
                    );
       VAR et {la et-indica fronto},
           eg {la eg-indica fronto}: entjera;
       STARTO
          et := unua;
          eg := lasta;
          DUM et < eg FARU STARTO
             DUM ordas(et, eg) KAJ (et < eg) FARU eg := ant(eg);
             permutu(et, eg);
             DUM ordas(et, eg) KAJ (et < eg) FARU et := sek(et);
             permutu(et, eg);
          FINO;
          SE unua < ant(et) TIAM rapid(unua, ant(et), ordas, permutu);
          SE sek(et) < lasta TIAM rapid(sek(et), lasta, ordas, permutu);
       FINO;

            {--- sekvas deklaroj, necesaj por ordigi vektoron v: ---}

       VAR v: TABELO [0..99] EL reela;

       FUNKCIO kreske(i, j: entjera): Bulea;
          STARTO kreske := (v[i] ≤ v[j]);
          FINO;

       PROCEDURO aroko(i, j: entjera);
          VAR lab: reela;
          STARTO lab := v[i]; v[i] := v[j]; v[j] := lab;
          FINO;

    {Ekzempla voko:}     rapid(0, 99, kreske, aroko);

### Vektora realigo de stako

       KONST stakAlto = 1000; {maksimuma nombro de stakigeblaj elementoj}
       TIPO  T = reela;       {stakigotaj datumoj}
       VAR   pinto: entjera;
             stako: TABELO [1 .. stakAlto] EL T;

       PROCEDURO surstakigu(x: T);
          STARTO
             SE pinto ≤ stakAlto TIAM STARTO
                stako[pinto] := x;
                pinto := pinto + 1;
             FINO ALIE eraro('surstakigo sur plenan stakon');
          FINO;

       PROCEDURO elstakigu(VAR y: T);
          STARTO
             SE pinto > 1 TIAM STARTO
                pinto := pinto - 1;
                y := stako[pinto]
             FINO ALIE eraro('elstakigo el malplena stako');
          FINO;

    STARTO        {de la programo; la komencvalorizo:}
       pinto := 1;  { ... }

### Solvo de la problemo pri la Nederlanda standardo en Paskalo

    VAR ruĝo, blanko, bluo: numero;
    STARTO
      ruĝo := 1;
      blanko := n;
      bluo := n;
      DUM blanko ≥ ruĝo FARU
        KAZO kia(blanko) EL
          ruĝa:   STARTO
                     permutu(blanko, ruĝo);
                     ruĝo := ruĝo + 1;
                  FINO;
          blanka: blanko := blanko - 1;
          blua:   STARTO
                     permutu(blanko,bluo);
                     blanko := ant(blanko);
                     bluo := ant(bluo);
                  FINO
        FINO
    FINO.

     +---+----+----+---+----+--+-----+-----+-----+----+-----+----+
     |ru | ru | ru |???????????| bla | bla | bla |blu | blu | blu|
     +---+----+----+---+----+--+-----+-----+-----+----+-----+----+
                    ^ru       ^bla            ^blu