Krestomatiaj algoritmoj
- La Eratostena kribrilo: en Paskalo
- Ekzempla senkondiĉa iteracio:
funkcio «prima» en MODULA
- La Hanojaj turoj: en Paskalo
- kopiuTekston: Programo kun ingita iteracio
- Faktorialoj: rikure iteracia kaj rekursia realigoj
- Duoniga serĉo en Paskalo
- La bobelmetoda ordigo: en Paskalo
- La Rapida ordigo: en Paskalo
- Vektora stako: Realigo en Paskalo, per vektoro
- La Nederlanda standardo: en Paskalo
- La 8 damoj: en Paskalo
- Ekzemplo pri
rekursia desupriĝo: en Paskalo
- La piramida ordigo: en Paskalo
- Larĝiĝema trairo de
grafeo: en Paskalo
- Profundiĝema
trairo de grafeo: en Paskalo
- Simpla stokastogenerilo:
en Paskalo
- Pli ĝenerala
stokastogenerilo: en MODULA
- La dormema frizisto: en MODULA
- La 5 filozofoj: en Ada
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.
Ĉ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
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 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 } |
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}
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]);
Ĉ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; { ... }
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