Sekvan paĝon! Antaŭan paĝon! Indekson! Instrukcion!

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));           {-- supra 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 
    OKAZO 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


Sekvan paĝon Indekson Instrukcion
Hosted by uCoz