Post By Telek:

MosML

fun piwo "Tyskie" = "dobre" - przypisanie wyniku dla argumentu
| piwo "Lech" = "dobre" -
| piwo _ = "zle"; - deklaracja odpowiedzi w innym przypadku niż założone jako ‘dobre‘
piwo "10.5"; - wywołanie funkcji „piwo” dla wartości 10.5

fun silnia 0=1 – zdefiniowanie wyniku funkcji dla konkretnego przypadku
| silnia n = n * silnia (n-1); - ogólny wzór funkcji
silnia ~1; - wywolanie funkcji dla wartości –1

exception BLAD – definicja informacji wyświetlonej przy błędnie podanej wartości funkcji
fun silnia2 n = if n = 0 then 1
else if n > 0 then n * silnia2(n-1)
else raise BLAD;
silnia2(~1) handle BLAD =>
(print "#$#%...";1);
silnia2(5) handle BLAD => 1;


infix mem – użycie nazwy wywoływanej funkcji pomiędzy elementami
fun el mem [] = false – gotowa odpowiedź w przypadku listy pustej
| el mem (x1:s) = el = x1 orelse - rozbicie listy na element pierwszy oraz resztę
el mem xs; - ustawienie rekurencji funkcji
1 mem [3,1,0]; - wywołanie funkcji sprawdzającej czy 1 należy do listy [3,1,0]


edit:
jeśli ktoś pamięta co jest w funkcji silnia2 niech dopisze bo u mnie zapanowała skleroza i nie czaję tego 'handle'.









zad2.7 z tematów egz by Piotrek

infix 6 ++;
infix 7 --;
infix 9 **;
infix 9 //;

fun (a,b) ++ (c,d) = (a+c,b+d);

fun (a,b) -- (c,d) = (a-c,b-d);

fun (a,b) ** (c,d) = ((a*c-b*d) , (a*d+b*c));

brakuje tylko funkcji na dzielenie liczb zepolonych

zad11

exception brak;

fun Podzielna (odLiczby , doLiczby , dzielnik) =
if doLiczby mod dzielnik = 0 then doLiczby else
if odLiczby < doLiczby then Podzielna (odLiczby,doLiczby -1,dzielnik) else raise brak;

Podzielna(5,12,20);

zad2.10

fun pierwsza' (n , 2) = ((n mod 2) <> 0)
| pierwsza' (n , k) = if ((n mod k) = 0)
then false
else pierwsza' (n, k-1);

fun pierwsza (n) = (pierwsza' (n, n-1) = true);

znalazłem coś na forum 2FD. Jak ktoś się zna to niech to sprawdzi:

lab4cz1 zad 2.
type lista = int list;

fun Min [] = NONE
| Min [x] = SOME(x)
| Min (x::y::l) = if x<y then Min(x::l) else Min(y::l);

val Lista = [1,3,2,~3,5,0];
Min [];
Min [1];
Min (Lista);

lab4cz1 zad 10

fun nty([],y)=NONE
| nty(x::xs,y)=if length(x::xs)>y then
if y=0 then SOME(x) else nty(xs,y-1)
else if length(x::xs)=y then NONE
else nty([],1);

nty([1,2,3,4,5,6,7],3);
oczywiście z forum 2FD

coś pomieszalo sie w poprzednim poście :: zamieniło się na :buźka więc zmieńcie sobie

Niezbędna wiedza w pigułce :D

Ułamki: zmodyfikuj funkcję naString – tak, by ułamek był wyświetlany w postaci właściwej,
load "Int";
fun NWD(0,n) = n
| NWD(m,n) = NWD(n mod m, m);
fun naString(l,m) =
let val znak = if l*m<0 then "~" else ""
val al = abs l
val am = abs m
val d = NWD(al, am)
val lt = al div d;
val mt = am div d;
val cal = lt div mt;
val resz = lt mod mt;
in znak ^ (Int.toString(cal)) ^ " " ^ (Int.toString(resz))
^ "/" ^ (Int.toString(mt))
end;
naString (4,3);
………………………………………………………………………………………………………..
Zadeklaruj i przetestuj działanie funkcji pierwsza: int®bool, gdzie pierwsza
(n)=true wtedy i tylko wtedy, gdy n jest liczba pierwszą.

fun pierwsza1 (n,1) = 1
| pierwsza1 (n,k) = if ((n mod k) = 0) then pierwsza1 (n,k-1) else 0;

fun pierwsza (n) = if pierwsza1 (n, n-1) = 1 then true else false;
……………………………………………………………………………………………………………..
Zadeklaruj i przetestuj działanie funkcji podzielnaOdDo(od,do,dzielnik):
int*int*int®int, wyszukującej najmniejszą liczbę z przedziału od...do podzielną
przez dzielnik.
exception Blad_Przedzialu;
fun PodzielnaOdDo (liczba_od, liczba_do, dzielnik) =
if (liczba_od = liczba_do)
then if ((liczba_od mod dzielnik) = 0)
then liczba_od
else 0
else if (liczba_od > liczba_do)
then raise Blad_Przedzialu
else if ((liczba_od mod dzielnik) = 0)
then liczba_od
else PodzielnaOdDo(liczba_od+1, liczba_do,dzielnik);
PodzielnaOdDo (3 , 6 , 2);
………………………………………………………………………….



Zadeklaruj funkcję usunNieparzyste,
type lista = int list;
fun usunNieparzyste[]=[]
| usunNieparzyste[x]=[]
| usunNieparzyste(x::y::l:lista)=y::usunNieparzyste(l);
val Lista = [1,2,3,4,5,6];
usunNieparzyste(Lista);
………………………………………………………………
Podaj deklarację funkcji typu int list -> int option odszukującej najmniejszy element z
listy liczb całkowitych.
type lista = int list;
fun Min [] = NONE
| Min [x] = SOME(x)
| Min (x::y::l) = if x<y then Min(x::l) else Min(y::l);
val Lista = [1,3,2,5];
Min (Lista);
…………………………………………………………………….
Podaj definicję funkcji nty typu 'a list*int -> 'a option, która zwraca n-ty element na
podanej liście (licząc od zera) .
fun enty(n,[]) = NONE
| enty(n,x::xs) = if (n>length(xs)) then NONE else
if (n=1) then SOME (x)
else enty(n-1,xs);
enty(3,[1,2,3,4,5,6,7]);
……………………………………………………………………….
Zaproponuj funkcję wstaw typu 'a list * int * 'a: 'a list wstawiającą do listy na
podane miejsce (licząc od zera) określony element.
fun wstaw (el,[])=[el]
| wstaw ((es,er),(x1s,x1r:real)::xs) =
if x1r < er then (x1s,x1r:real)::wstaw((es,er),xs)
else (es,er)::(x1s,x1r:real)::xs;
………………………………………………………………………………
Napisz funkcję sprawdzającą, czy w rejestrze w kasie sklepowej nie występują powtórzenia „kodów kreskowych”.
type kodArt = string;
type nazwaArt = string;
type cena = int;
type rejestr = (kodArt*(nazwaArt*cena)) list;
local
fun nowa ( (ka',naz_cen_A') , [] : rejestr ) = false
| nowa ( (ka',naz_cen_A') , (ka2',naz_cen_A2') :: ogon ) =
if ka'=ka2'
then true
else nowa ( ( ka',naz_cen_A' ) , ogon );
in
fun jakis ( [] : rejestr) = false
| jakis ( ( ka , naz_cen_A ) :: rej ) =
if ( nowa ( ( ka , naz_cen_A ) , rej ) )
then true
else jakis( rej )
end;
val Rejestr =
[ ("a1", ("ser bialy", 3)),
("a2", ("szprotki", 2)),
("a1", ("sok", 4))
];
val Rejestr2 =
[ ("a1", ("ser bialy", 3))];
jakis(Rejestr);
jakis(Rejestr2);
………………………………………………………………
Zmień ceny w rejestrze kasy sklepowej, tak by były wartościami typu real. Oblicz średnią cenęartykułu. Wsk.: może to być kilka funkcji.

type rejestr = ( string * ( string * real ) ) list;
local
fun suma ( [] : rejestr ) = 0.0
| suma ( ( ka , ( nazwa , cena ) ) :: rej ) = cena + suma ( rej );
fun ile ( [] : rejestr ) = 0.0
| ile ( ( ka , ( nazwa , cena ) ) :: rej ) = 1.0 + ile ( rej );
in
fun srednia ( [] : rejestr ) = 0.0
| srednia ( ( ka , ( nazwa , cena ) ) :: rej ) =
( suma ( ( ka , (nazwa , cena ) ) :: rej ) ) / ( ile ( ( ka , (nazwa , cena ) ) :: rej ) );
end;
val Rejestr =
[ ( " a1 " , ( " ser bialy " , 2.0 ) ),
( " a2 " , ( " mleko " , 3.0 ) ),
( " a3 " , ( " maslo " , 4.0 ) )
];
srednia ( Rejestr );
…………………………………………………………………………………………….
Wyszukaj wszystkie artykuły o cenach zawartych w podanym zakresie (min,max).

type rejestr = ( string * ( string * int ) ) list;
fun miedzy ( min , max , [] : rejestr ) = []
| miedzy ( min , max , ( ka , ( nazwa , cena ) ) :: rej ) =
if ( cena >= min ) andalso ( cena <= max )
then ( ka , ( nazwa , cena ) ) :: miedzy ( min , max , rej )
else miedzy ( min , max , rej );
val Rejestr =
[ ( " a1 " , ( " ser bialy " , 1 ) ),
( " a2 " , ( " mleko " , 5 ) ),
( " a6 " , ( " jogurt " , 2 ) )
];
miedzy ( 1 , 3 , Rejestr );
……………………………………………………………………………
Wyszukaj za pomocą odpowiedniej funkcji najtańszy artykuł w sklepie.
type rejestr = ( string * ( string * int ) ) list;

fun min ( [] : rejestr ) = []
| min [ ( ka , ( nazwa , cena ) ) ]= [ ( ka , ( nazwa , cena ) ) ]
| min ( ( ka_1 , ( nazwa_1 , cena_1 ) ) :: ( ka_2 , ( nazwa_2 , cena_2 ) ) :: rej ) =
if ( cena_1 < cena_2 )
then min ( ( ka_1 , ( nazwa_1 , cena_1 ) ) :: rej )
else min ( ( ka_1 , ( nazwa_2 , cena_2 ) ) :: rej );
val Rejestr =
[ ( " a1 " , ( " ser bialy " , 1 ) ),
( " a2 " , ( " mleko " , 5 ) ),
( " a3 " , ( " maslo " , 3 ) )
];
min ( Rejestr );
…………………………………………………………………….
Wyszukaj za pomocą odpowiedniej funkcji najdroższy artykuł w sklepie.
type rejestr = ( string * ( string * int ) ) list;

fun max ( [] : rejestr ) = []
| max [ ( ( ka , ( nazwa , cena ) ) ) ] = [ ( ka , ( nazwa , cena ) ) ]
| max ( ( ka_1 , ( nazwa_1 , cena_1 ) ) :: ( ka_2 , ( nazwa_2 , cena_2 ) ) :: rej ) =
if ( cena_1 > cena_2 )
then max ( ( ka_1 , ( nazwa_1 , cena_1 ) ) :: rej )
else max ( ( ka_1 , ( nazwa_2 , cena_2 ) ) :: rej );
val Rejestr =
[ ( " a1 " , ( " ser bialy " , 1 ) ),
( " a2 " , ( " mleko " , 5 ) )
];
max ( Rejestr );

val y =2*2;

fun piwo "tyskie" = "dobre"
| piwo "lech" = "dobre"
| piwo _ = "zle";



(* element nalezy do listy ?
->[1,2,0,~1] *)
infix mem
fun el mem [] = false
| el mem (x1::xs) = el =x1 orelse

el mem xs;

(* 1 mem [3,1,0]*)


(* 1 mem [3,1,0]

Post został pochwalony 0 razy

Ostatnio zmieniony przez adminfz dnia Pon 17:11, 10 Gru 2007, w całości zmieniany 1 raz