1. Ułamki: zmodyfikuj funkcję naString – tak, by ułamek był wyświetlany w postaci właściwej, czyli część całkowita i ułamkowa. Wskazówka



Pobieranie 47 Kb.
Data02.05.2016
Rozmiar47 Kb.
1. Ułamki: zmodyfikuj funkcję naString – tak, by ułamek był wyświetlany w postaci właściwej, czyli część całkowita i ułamkowa. Wskazówka: po wyznaczeniu wartości bezwzgl. licznika i mianownika wydziel część całkowitą przez dzielenie div i pozostały licznik – reszta z dzielenia, operator mod. Podstawowa wersja funkcji znajduje się w pliku do egzaminu.
load "Int";

load "String";


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 calk = al mod am

val calk = if calk=0 then "" else Int.toString(calk)

val al=al div am

val d = NWD(al, am)

in znak ^ calk ^ "" ^ (Int.toString( al div d )) ^ "/"

^ (Int.toString( am div d) )

end;


naString(12,3);
2. Opracuj zestaw funkcji arytmetycznych dla liczb zespolonych (++,--,**). Sprawdź działanie tych funkcji na kilku przykładach.
infix 7 **

infix 6 ++

infix 6 --

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);



(5,2)++(3,4);
3. Zadeklaruj infiksowy operator równoważności, implikacji i exor w dziedzinie danych typu booli,sprawdź jego działanie ze szczególnym uwzględnieniem priorytetu.
infix 8 rownowaznosc

infix 7 implikacja

infix 9 exor

fun (a) rownowaznosc (b) = ( a andalso b ) orelse ( (not a) andalso (not b));

fun (a) implikacja (b) = not( a orelse b );

fun (a) exor (b) = ( (not a) andalso b ) orelse (a andalso (not b));



(true) exor (false);
4. Zadeklaruj i przetestuj działanie funkcji pierwsza: int→bool, gdzie pierwsza (n)=true wtedy i tylko wtedy, gdy n jest liczba pierwszą. Wsk.: Liczba pierwsza to taka, której

podzielnikami są tylko 1 i ona sama. Skonstruuj funkcję pomocniczą pierwsza’ z dwoma

wariantami (kończącym rekurencję) pierwsza’(n,2) i pierwsza’(n,k) wywoływaną przez zasadniczą: fun pierwsza n = pierwsza' (n,n-1);
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));



pierwsza(6);
5. Podaj deklarację funkcji typu int * string list -> string odszukującej najmniejszy element z listy. Zadeklaruj przykładową daną i zademonstruj działanie funkcji.
type rejestr=(int*string) list;
val Rejestr=

[

(2,"ketchup"),



(4,"masło"),

(6,"chleb"),

(100,"piwo")

];
fun najmn([]:rejestr) = []

|najmn[(kod,nazwa)] = [(kod,nazwa)]

|najmn( (kod1,nazwa1)::(kod2,nazwa2)::rej ) = if (kod1

then najmn((kod1,nazwa1)::rej)

else najmn((kod1,nazwa2)::rej);



najmn(Rejestr);
6. Podaj deklarację funkcji typu int * (string * string) list -> string * string odszukującej najmniejszy element z listy.
type rejestr=(int*(string*string) ) list;
val Rejestr=

[

(2,("ketchup","kotlin")),



(4,("masło","osełkowe")),

(6,("chleb","żytni")),

(3,("piwo","Lwivskie PRemium"))

];

fun najmn([]:rejestr) = []



|najmn[(kod1,(nazwa1,marka1))] = [(kod1,(nazwa1,marka1))]

|najmn( (kod1,(nazwa1,marka1))::(kod2,(nazwa2,marka2))::rej ) =

if (kod1

else najmn( ((kod1,(nazwa2,marka2))::rej) );



najmn(Rejestr);
7. Podaj deklarację funkcji sortującej dane typu int * string list gdzie kluczem jest liczba całkowita. Zadeklaruj przykładową daną i zademonstruj działanie funkcji.
fun wstaw(x,[]) = [x]

| wstaw( (k1,(n1,c1)) , ((k2,(n2,c2))::t)) = if c1<=c2 then

(k1,(n1,c1))::(k2,(n2,c2))::t

else (k2,(n2,c2)) :: wstaw( (k1,(n1,c1)) ,t) ;

fun sortuj [] = []

| sortuj(h::t) = wstaw(h, sortuj t);


val art1 = { kod = "1234", nazwa = "sok1", cena = 12};

val art2 = { kod = "1204", nazwa = "sok2", cena = 11};

8. Podaj definicję funkcji nty typu 'a list*int -> 'a, która zwraca n-ty element na podanej

liście (licząc od zera) . Zadeklaruj przykładową daną i zademonstruj działanie funkcji.
val Rejestr=[123,42,34,234,111,23];
fun nty(0,x1::xs) = x1

|nty(n,x1::xs) = nty(n-1,xs)

|nty _ = 0;

nty(4,Rejestr);
9. Zaproponuj funkcję wstaw typu 'a list * int * 'a: 'a list wstawiającą do listy na podane miejsce (licząc od zera) określony element. Zadeklaruj przykładową daną i zademonstruj działanie funkcji.
val x=[1,132,13,123,1,2,132];
fun wstaw(x1::x,miejsce, element) = if miejsce=0 then

element::wstaw(x,miejsce-1,element)

else x1::wstaw(x, miejsce-1, element)

| wstaw _ = [];



wstaw(x,3,6);
10. Podaj definicję funkcji usunnty typu 'a list*int -> 'a list, która usuwa n-ty element

na podanej liście (licząc od zera) . Zadeklaruj przykładową daną i zademonstruj działanie

funkcji.
val x = [1, 2, 53, 4, 75, 48, 102, 26];
fun usun(x::list, miejsce) = if miejsce=0 then

usun(list, miejsce-1)

else x::usun(list,miejsce-1)

| usun _ = [];



val usun = usun(x,3);
11. 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))

];

jakis(Rejestr);
12. 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. Zadeklaruj przykładową daną i zademonstruj działanie funkcji.
type rejestr=(string*(string*real)) list;

val Rejestr =

[ ("a1", ("ser bialy", 3.0)),

("a2", ("szprotki", 2.0)),

("a1", ("sok", 4.0))

];

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);

fun srednia([]:rejestr) = 0.0

| srednia( (ka,(nazwa,cena))::rej ) = ( suma

((ka,(nazwa,cena))::rej)) / (ile((ka,

(nazwa,cena))::rej));

srednia(Rejestr);
13. Wyszukaj wszystkie artykuły o cenach zawartych w podanym zakresie (min,max).
val Rejestr =

[ ("a1", ("ser bialy", 3)),

("a2", ("szprotki", 2)),

("a3", ("sok", 4)),

("a4",("Lizak", 7))

];

fun minmax(min,max,(ka,(nazwa,cena))::rej)



= if cena>min andalso cena

::minmax(min,max,rej)

else minmax(min,max,rej)

| minmax _ = [];



minmax(2,7,Rejestr);

14. Wyszukaj za pomocą odpowiedniej funkcji najtańszy artykuł w sklepie.
type rejestr=(string*(string*int)) list;

val Rejestr =

[ ("a1", ("ser bialy", 3)),

("a2", ("szprotki", 2)),

("a3", ("sok", 4)),

("a4",("Lizak", 7))

];

fun tiny([]:rejestr) = []



|tiny[(ka,(nazwa,cena))]=[(ka,(nazwa,cena))]

|tiny( (ka1,(nazwa1,cena1))::(ka2,(nazwa2

,cena2))::rej ) = if (cena1

then tiny( (ka1,(nazwa1,cena1))::rej ) Else

tiny( (ka1,(nazwa2,cena2))::rej );

tiny(Rejestr);


15. Znajdź n-artykułów najdroższych w sklepie. Utwórz odpowiednią funkcję. Wsk.: najpierw

posortuj. Zadeklaruj przykładową daną i zademonstruj działanie funkcji.
val SKLEP = [art1,art2,art3,art4,art5,art6,art7,art8,art9];
fun wstaw(x,[]) = [x]:real list

| wstaw(x,h::t) = if x<=h then x::h::t else h::wstaw(x,t);


fun sortuj [] = []

| sortuj(h::t) = wstaw(h, sortuj t);


type dana = { kod:string, nazwa:string, cena:int};
fun wstaw'(x:dana,[]) = [x]

| wstaw'(x,h::t) = if #kod x<= #kod h then x::h::t else

h::wstaw'(x,t);
fun sortuj' [] = []

| sortuj'(h::t) = wstaw'(h, sortuj' t);


sortuj' SKLEP;

16. Wyszukaj za pomocą odpowiedniej funkcji najdroższy artykuł w sklepie.
type rejestr=(string*(string*int)) list;

fun drogi( []:rejestr ) = []

| drogi[ (KA',(nazwa',cena'))]=

[ (KA',(nazwa',cena'))]

| drogi


((KA,(nazwa,cena))::(ka,(n,c))::rej)

= if cena > c then drogi

((KA,(nazwa,cena))::rej)

else drogi((KA,(n,c))::rej);

val Rejestr =

[ ("a1", ("ser bialy", 12)),

("a2", ("szprotki", 2)),

("a3", ("Lech", 5)) ];



drogi(Rejestr);

21.

val a =At "a" and b = At "b" and c = At "c" and d = At "d" and p = At "p" and q = At "q" and i = At "i";

fun NOT(p) = !!p;

fun NOR(p,q) = !!(p ++ q);

fun NORBIG(p,q,i) = !!(p ++ q ++ i);

val y1 = NOT(a);

val y2 = NOR(b,c);

val y3 = NOR(c,d);

val y4 = NORBIG(y1,y2,y3);

val ys = a**(b ++ c**d);

val twierdzenie = ys<=>y4;

check twierdzenie;
22.

fun AND(p,q) = p ** q;

fun NOT(p) = !!p;

fun NAND(p,q) = !!(p ** q);

fun NAND3(p,q,i) = !!(p ** q ** i);

fun ORBIG(p,q,i) = p ++ q ++ i;

val y1 = AND(b,a);

val y2 = NAND((NOT(a)),c);

val y3 = NAND3((NOT(c)),a,d);

val Y = ORBIG(y1,y2,y3);

fun OR(p,q) = p ++ q;



val Z = OR(a,(NOT(c)));

val twierdzenie_ogolne = Y<=>Z;

check twierdzenie_ogolne;
23. Zaproponuj układ złożony z bramek, który zrealizuje taką funkcję:

fun AND(x1,x2,x3)= x1**x2**x3;

fun BIGOR(x1,x2,x3,x4)= x1++x2++x3++x4;

val and1= AND(!! a, !! b, !! d);

val and2= AND(!! a, c, d);

val and3= AND(b, !!c, d);

val and4= AND(a, !!b, !!c);

val calosc = BIGOR(and1,and2,and3,and4);



check calosc;
24

val x1 =At "x1" and x2 = At "x2" and x3 = At "x3" and p = At "p" and q = At "q" and i = At "i";
fun N(p) = !!p;

fun N2(p,q,i) = !!(p**(!!(!!q**i)));

val y1 = N(x2);

val y2 = N2(x3,x1,x2);
val x1=At"x1" and x2=At"x2" and x3=At"x3"

and x4=At"x4"and a=At"a" and b=At"b"

and c=At"c" and d=At"d";

fun NAND(a,b)= !!(a**b);

val tw1= NAND(x2,x2);

val tw1b= !! x2;



val cal= tw1<=>tw1b;

check cal;

val tw2a= NAND(x1,x1);

val tw2b= !! x1;

val cal2= tw2a<=>tw2b;

check cal2;

val tw3a= NAND(tw2b,x2);

val tw3b= !!( !!x1 ** x2 );

val cal3= tw3a <=> tw3b;

check cal3;

val tw4a= NAND(tw3b,x3);

val zapis= !!( !!x1 ** x2) ** x3;

val spraw = (zapis <=> tw4a);

check spraw;

fun NAND(p,q)= !!(p**q);


val tw1=NAND(p,p);

val spr1= !!p;

val cal1= tw1<=>spr1;

check cal1;


val tw2= NAND(q,q);

val spr2= !!q;

val cal2= tw2<=>spr2;

check cal2;


val tw3= NAND(spr2,i);

val spr3= !!( spr2 ** i );

val cal3= tw3<=>spr3;

check cal3;


val tw4= NAND(spr3,l);

val spr4= !!(spr3 ** l);

val cal4= tw4<=>spr4;

check cal4;



val wzor =!! ( !!( !!q ** i ) ** l);

Pobieranie 47 Kb.





©absta.pl 2020
wyślij wiadomość

    Strona główna