Példaprogramok
Egy pici tekenyilvántartó program:
begin
mode person = struct(string name, int score, ref person next);
ref person first := nil, ptr;
string bowler;
int bowled;
bool still looking;
make term(stand in, " "); # space legyen a string elvasztó az stdin-en #
while read((bowled,bowler)); bowled 0
do
first := heap person := (bowler,bowled,first)
od;
while read((newline,bowler)); bowler # " " # soron belüli # valójában áthúzott = #
do
ptr := first; still looking := true;
while (ptr :#: ref person(nil)) ^ still looking # soron belüli # valójában áthúzott = #
do
if name of ptr = bowler
then
print((bowler, score of ptr, newline));
still looking := false
else
ptr := next of ptr
fi
od;
if still looking then
print((bowler, "not in our league",new line))
fi
od
end
Egy program a 99 sörösüvegről:
# 99 Bottles of Beer #
( PROC width = (INT x) INT: (x>9 | 2 | 1)
; FOR i FROM 99 BY -1 TO 1
DO printf ( ( $ 2l n(width(i))d
, x "bottle" b("","s") x "of beer on the wall,"
, x n(width(i))d
, x "bottle" b("","s") x "of beer."
, l "Take one down, pass it around,"
, x n(width(i-1))d
, x "bottle" b("","s") x "of beer."
$
, i , i=1
, i , i=1
, i-1, i=2
) )
OD
)
Az n-vezér problémát megoldó, működő Algol-68 program: (A68S fordítóhoz)
PR UPPER .PR
# Ez a pragma azert kell, hogy ne kelljen a kulcsszavak ele pontot tenni, #
# hanem a nagybetu jelzi, hogy mi a kulcsszo. #
BEGIN
LOC INT db:=0; # A megoldasok szama #
LOC INT n; # A tabla merete #
LOC INT m:=1; # Ez mutatja, hogy meddig jo #
LOC INT c:=0; # Ez mutatka, hogy a vegen vagyunk-e #
LOC BOOL l:=FALSE; # Talaltunk-e megoldast. #
print(("A tabla nxn-es? n="));
read((n,newline));
# A tablameret bekerese. #
LOC [1:n] INT tabla;
# Valtozo hosszu tomb definialasa #
# Es kezdoertekenek beallitasa #
FOR i TO n
DO
tabla[i]:=1
OD;
COMMENT
Ez a resz allapitja meg, hogy az elso m+1 db kiralyno jo helyen van-e.
COMMENT
PROC ro = BOOL:
BEGIN
LOC BOOL l:=TRUE;
FOR i TO m WHILE l
DO
l:=(NOT(tabla[m+1]=tabla[i]) AND NOT(ABS(m+1-i)=ABS(tabla[m+1]-
OD;
l
END;
COMMENT
A megoldas kiiratasa.
COMMENT
PROC kiir = VOID:
BEGIN
db:=db+1;
print(( "A(z) ",whole(db,0), ".megoldas: "));
FOR i TO n DO print((whole(tabla[i],0),(i=n|""|","))) OD;
print((newline))
END;
COMMENT
Megadja az elso olyan helyet, ahol mar utik egymast a vezerek.
Ha ilyen nincs, akkor ez egy jo megoldas.
Visszaadja, hogy a megoldas jo-e.
COMMENT
PROC keres = BOOL:
BEGIN
LOC BOOL l:=TRUE;
m:=m-1;
WHILE (NOT(m=n) AND l)
DO
l:=ro;
m:=m+1
OD;
l
END;
COMMENT
Az allas nem volt jo, ezert az egyik kiralynot feljebb teszi, illetve ha
legfelul van, akkor legalulra teszi, es az elozovel teszi ugyanazt.
Ha a legelsot kellene legfelulrol feljebb tenni, az az jelenti, hogy
vegigertunk, igy c-t is beallitjuk.
COMMENT
PROC novel = VOID:
BEGIN
c:=1;
WHILE (c=1 AND m>0)
DO
IF (tabla[m]=n) THEN
tabla[m]:=1;
m:=m-1
ELSE
tabla[m]:=tabla[m]+1;
c:=0
FI
OD
END;
COMMENT
A fo ciklus, amely keresi a megoldasokat. Vege, ha c=1.
COMMENT
WHILE (c=0)
DO
l:=keres;
IF l THEN kiir FI;
novel
OD;
IF db=0 THEN print(("Nincs megoldas.",newline)) FI
#Ha megsem volt megoldas...#
END
És még pár példaprogram:
- példa eljárásváltozóra:
begin # Eljaras valtozo. #
proc(int)int myproc;
myproc := (int i)int:i+1;
print(myproc(10));
myproc := (int j)int:j-1;
print(myproc(10))
end # Kepernyore: 11, 9.#
- legnagyobb közös osztó kiszámítása:
begin # Legnagyobb kozos oszto. #
proc gcd=(int a,b)int:
( b=0 |abs a | gcd(b,a mod b) );
while
int a,b; print((newline, "two integers please : "));
read((a,b));
a>0 or b>0 do
print((blank*15,"gcd of ",a,"and ",b,"is ",gcd(a,b)))
od
end # Kiirja a bekert ket szam lnko-jat. #
- különböző számolások:
begin # Kulonbozo szamolasok. #
proc sum=(int n,proc(int)real p)real:
begin reals:=0;
for i to n do s+:=p(i) od;
s
end;
print((sum(10,(int j)real:sin(2*pi*j/10)),newline,
sum(10,(int j)real:cos(2*pi*j/10))));
print((sum(60,(int j)real:sin(2*pi*j/120))/60,newline,
sum(50,(int j)real:sin(2*pi*j/100))/50,newline,
sum(40,(int j)real:sin(2*pi*j/80))/40,newline,
sum(30,(int j)real:sin(2*pi*j/60))/30,newline,
sum(20,(int j)real:sin(2*pi*j/40))/20,newline,
sum(60,(int j)real:cos(2*pi*j/120))))
end
- függvénykirajzolás:
begin # Rajzolas (csavartvonal). #
real c=2*pi;
proc f=(real x)real:exp(-x)*sin(c*x);
real d=.0625,s=32;inth=34,lim=30;
for i from 0 to lim do
real y=f(d*i);
print((blank*(round(s*y)+h),"*",newline))
od
end
- operátorok definiálása:
begin # Operatorok. #
op?=([]real a)real:
(upb a=1|a[1]|a[1]+1.0/?a[2:]);
[]real x=(1,1,1,1,1,1,1,1), y=(1,2,3,4,5,6,7,8);
print((?x,newline,?y))
end # Kiirja: 1.61905, 1.43313 #
- másodfokú egyenlet megoldása unió segítségével:
begin # Masodfoku egyenlet megoldasa. #
mode rc=union(real,compl);
proc qe=(real a,b,c)[]rc:
# Vannak-e valos gyokei? #
if real d:=b^2-4*a*c; d>0
then d:=sqrt(d)/2/a;
(-b/2/a+d,-b/2/a-d)
elif d=0
then-b/2/a
else d:=sqrt(-d)/2/a;
real re=-b/2/a;
(re i d,re i -d)
fi;
while
real a,b,c;
print((newline,"the coefficients, please : "));
read((a,b,c));
a/=0
do
print(qe(a,b,c))
od
end # Kiirja a gyokoket (ha komplex, akkor is). #
- permutációk kiíratása:
begin # Permutaciok. #
int n; read(n);
proc perm=(ref[]int a)void:
(int n=upb a;
if n=1 then printperm
else to n do
perm(a[:n-1]);
int a1=a[1];
a[:n-1]:=a[2:];
a[n]:=a1
od
fi
);
proc printperm=void:
(for i to n do print(t[i])od;
print(newline));
[n]int t; for i to n do t[i]:=i od;
perm(t)
end # Kiirja az 1-n szamok osszes permutaciojat.#
- faktoriális kiszámítása (az ejárás önmaga paramétere):
begin # Eljaras, mint onmaga parametere. #
mode p=proc(p)int;
proc fact=(p f)int:
(i=0|1|int j=i; i-:=1; j*f(f));
proc q=(int n)int:(i:=n; fact(fact));
int i;
for i to 10 do print((q(i),newline)) od
end # Kiirja 1-10-ig a szamok faktorialisat. #
- öröknaptár:
begin # Oroknaptar. #
proc what=(int month,day,year) void:
(bool greg= year>1582 or year=1582 and month*100+day>=1015;
bool leap=year%*4=0 and
(not greg or year%*100/=0 or year%*400=0);
int r=day+year
+ case month in 0,3,3,6,1,4,6,2,5,0,3,5 esac
+ if greg then
int j=year-1600;
year%4-j%100+j%400-10
else year%4
fi
- abs(leap and month<3);
print((blank*17,"that day is ",
case r%*7 in "Friday","Saturday","Sunday",
"Monday","Tuesday","Wednesday"
out"Thursday" esac, newline))
);
while int month,day,year;
print("your date (month, day, year)? ");
read((month,day,year));
month>0 and month<13
do what(month,day,year)
od
end
- faktoriális kiszámítása egy helyes és hibás módon:
begin # Hiba!!! #
int n; read(n);
begin
proc(int)int f=(int i)int:(i=0|1|i*f(i-1));
proc g=(int i)int:(i=0|1|i*g(i-1));
print(g(n));print(f(n))
end
end # A g kiirja a szamok faktorialisat. #
# Az f-nel hibat kapunk. #
- az Algol68 "furcsaságait" (operátorok és a prioritás felüldefiniálása, ortogonalitás) bemutató program:
(az interpreter miatt kell a kulcsszavat ''-ek közé tenni)
'begin'
print(("Kerek ket szamot: ",newline));
# Változó nevében lehet szóköz is #
'int' elso szam, masodik szam;
print("A = "); read(elso szam);
print("B = "); read(masodik szam);
'int' a := elso szam, b := masodik szam;
# Az if szerkezenek is van visszatérési értéke, ez kerül kiíratásra #
print((newline,"A nagyobbik szam: ",'if' a>b 'then' a 'else' b 'fi'));
'proc' ('int', 'int') 'int' lnko fuggveny, f fuggveny;
# "lnko fuggveny" és "f fuggveny" eljárás típusú változók #
# az értékadáskor maga az eljárás törzse adódik értékül #
lnko fuggveny := ('int' x, 'int' y) 'int':
'begin'
# x1 és y1 változók azért szükségesek, mert érték szerinti paraméterátadás van #
# nem váloztathatók az x és y értékei #
# cím szerinti paraméterátadáskor pedig felülíródna az aktuális paraméter #
'int' x1 := x , y1 := y;
'while' (x1 > y1) 'or' (x1 < y1) 'do'
'if' x1 > y1 'then' x1 := x1-y1 'else' y1 := y1-x1 'fi'
'od';
x1
'end';
print((newline,"LNKO = ",lnko fuggveny(elso szam, masodik szam)));
# a print paramétere gyakorlatilag akármilyen objektum lehet #
print((newline,"LKKT = ",
'begin'
'while' (a > b) 'or' (a < b) 'do'
'if' a > b 'then' a := a-b 'else' b := b-a 'fi'
'od';
elso szam*masodik szam/a
'end'));
f fuggveny := ('int' x, 'int' y) 'int': x+y*2;
print((newline,"A+B*2 = ",f fuggveny(elso szam, masodik szam)));
# operandusok prioritása felüldefiniálható #
'prio' + = 3, * = 2;
print((newline,"A+B*2 = ",f fuggveny(elso szam, masodik szam)));
# sőt a predefinit operátorok is felüldefiniálható #
'op' + = ('int' n, 'int' m) 'int': n;
print((newline,"A+B = ",elso szam + masodik szam))
# minden utasítást ;-vel kell elválasztani, az utolsót nem szabad, mert az üres utasítás #
# nem megengedett #
'end'