CONSTANTS

const nomConstant1 : tipus = valorConstant1; nomConstant2 : tipus = valorConstant2; ...fconst

const N: enter = 100;fconst

TIPUS

tipus color = {verd, blau, vermell groc, blanc}; dia = {dilluns, dimarts, dimecres, dijous}; mes = {gener, febrer, març, abril, maig};ftipus

VARIABLES

var nomVariable1 : tipusVariable1; nomVariable2 : tipusVariable2; ...fvar

var t: taula(N) de enter; i, n: enter;fvar

COMPOSICIÓ ALTERNATIVA

si expressio llavors accioa

sino acciob

fsi

si n > 0 llavors accio1sino accio2fsi

COMPOSICIÓ ITERATIVA

index := valor inicial;mentre index ≤ valor final fer accio; index := index + increment;fmentre

per index := valor inicial fins valor final [pas increment] acció;fper

ACCIONS

DECLARACIÓ:

acció nom(param1, param2, ... , paramn) ... cos de l’acciófacció

ASSIGNACIÓ:

nom de l’acció (obj1, obj2, ... , objn)

DECLARACIÓ:

acció suma(ent x: enter, sor y: enter, entsor z: enter) ... cos de l’acciófacció

ASSIGNACIÓ:

suma (x,y,z)

ACCIONS PREDEFINIDES

accio escriureEnter (ent e: enter) Acció que visualitza per pantalla el valor de l’enter e

accio escriureReal (ent r: real) Acció que visualitza per pantalla el valor del real r

accio escriureCaracter(ent c: caracter) Acció que visualitza per pantalla el valor del caràcter c

EXEMPLE

Intercanviar les variables enteres x i y, z i w i v i u.

Exemple d’algorisme sense acció:

{Pre: (x=X i y=Y) i (z=Z i w=W) i (v=V i u=U) }

aux := x;x := y;y := aux;aux:= z;z := w;w := aux;aux := v;v := u;u := aux;

{ Post: (x=Y i y=X) i (z=W i w=Z) i (v=U i u=V) }

Exemple d’algorisme aplicant una acció:

accio intercanvia (entsor x: enter, entsor y: enter) var aux: enter; fvar aux := x; x := y; y := aux;facció

Podríem invocar l’acció en l’algorisme:

algorisme intercanviarValors{Pre: (x=X i y=Y) i (z=Z i w=W) i (v=V i u=U) } intercanvia(x,y); intercanvia(z,w); intercanvia(u,v);{ Post: (x=Y i y=X) i (z=W i w=Z) i (v=U i u=V) }falgorisme

FUNCIONS

funció nom(param1, param2, ... , paramn): tipus ...retorna expressio;ffuncio

funcio esPrimer (n: enter): booleà...retorna primer;ffuncio

FUNCIONS PREDEFINIDESfuncio realAEnter(x: real): enterfuncio enterAREal(x: enter): realfuncio caracterACodi(x: caràcter): enterfuncio codiACaracter(x: enter): caracter

Funcions de conversió de tipus

funcio llegirEnter():enter Funció que retorna un enter introduït pel teclat del computador

funcio llegirCaracter():caracter Funció que retorna un caracter que ha estat introduït pel teclat del computador

funcio llegirReal():real Funció que retorna un real que ha estat introduït pel teclat del computador

ESQUEMA DE RECORREGUT D’UNA SEQÜÈNCIA

algorisme esquemaRecorregut var element: tipus; fvar element := llegir(); inici tractament mentre no fi sequencia fer (mentre no (element = marca) fer) tractar element avançar sequencia element := llegir(); fmentre tractament finalfalgorisme

ESQUEMA DE CERCA D’UNA SEQÜÈNCIAalgorisme esquemaCerca var trobat: boolea; element : tipus; fvar element := llegir(); trobat := fals; mentre no fi sequencia i no trobat fer (mentre no (element = marca) i no trobat fer actualitzar trobat si no trobat llavors tractar element avançar sequencia element := llegir(); fsi fmentre tractament finalfalgorisme

TAULES

var nom: taula[mida] de tipus;fvar

var recaptacioCinema: taula[7] de enter;fvar

OPERACIONS ELEMENTALSSi tenim la taulavar t:taula[10] de enter;fvar

podrem fer:

t[3] Accedim a l’element de tercera posició

Si tenim la taula

var aparicions: taula[26] de enter;fvar

podrem fer:

aparicions[1] fa referència al primer element de la taula, aparicions[2] al segon, aparicions[3] al tercer i així successivament.

ASSIGNACIÓ D’UNA TAULAt[5] := 11;

LECTURA I ESCRIPTURA

escriureEnter(t[2]) Escriu en el dispositiu de sortida el valor contingut en el posició 2 de la taula “t”.

escriureEnter(t) No té sentit. Provocaria Error

t[14] := llegirEnter() Llegeix una dada del dispositiu d’entrada i l’assigna a la posició 4 de la taula “t”.

t := llegirEnter() No té sentit. Provocaria Error

TAULES BIDIMENSIONALS

La declaració de l’exemple anterior seria: var recaptacioCinema: taula[7,3] de enter; fvarPer assignar una recaptació de 84, el divendres, a la sala 2: recaptacioCinema[5,2] := 84;declaració: varrecaptacioCinema: taula[7] de taula [3] de enter;fvar

Assignació: recaptacioCinema[5][2] := 84;

TUPLES

tipus proveidor: tupla nom: taula[15]de caracter;

telefon, fax: enter; ftupla

ftipus

var proveidor1, proveidor2: proveïdor;fvar

OPERACIONS ELEMENTALSACCÉS CORRECTE ACCÉS INCORRECTE

proveidor1.nom[1] {1er caràcter del camp nom de la tuplaproveidor1}proveidor2.telefonproveidor1.fax

nom[1] {No es pot fer referència al camp sense indicar el nom de la tupla}proveïdor.telefon{No es pot fer servir el tipus proveïdor com si for una variable}fax.proveidor1 {primer ha d’anar el nom de latupla i després el nom del camp}

ASSIGNACIÓ

proveidor1.telefon := 935847259;proveidor2.telefon := 934528632;

LECTURA I ESCRIPTURAa.x :=llegirReal() Llegeix una dada del dispositiu d’entrada i l’assigna al camp x de la tupla a.a := llegirReal() No té sentit, ja que implica operar amb la tupla sencera. Dóna error.escriureReal(a.x) Escriu en el dispositiu de sortida el valor contingut en el camp x de la tupla a.escriureReal(a) No té sentit, ja que implica operar amb la tupla sencera. Dóna error.

tipus llistaMes = {gener, febrer, març, abril, maig, juny, juliol, agost, setembre, octubre, novembre, desembre}; data = tupla dia: enter;

mes: llistaMes; any: enter; ftupla

ftipus

tipus nota = {N, D, C, B, A}; alumne = tupla

codiMatricula: enter;nom: taula [25] de caracter;adreçaE: taula[40]decaracter;notesPAC: taula[5] de nota;qualificació: nota;

ftuplaftipus

PROBLEMES RESOLTS

INTERCANVI DE VALORS

{ Pre: x= X i y = Y}aux := x;x := y;y := aux;{ Post: x=Y i y = X }

CALCULAR EL MÀXIM DE DOS NOMBRES ENTERS

{ Pre: x= X i y = Y}si x > y llavors z :=x;sinó z := y;fsi{ Post: z = màxim(X;Y) }

CALCULAR EL FACTORIAL D’UN NÚMEROEl factorial d’un nombre és el producte de tots els números des de l’1 fins al nombre. Exemple: El factorial de 5 és 5x4x2x1 = 120.

algorisme factorial var

i, n, fact := enter; fvar n := llegirEnter ();{Per: n = N i N > 0} fact := 1 //es parteix d’uns valors inicials i := 1 // Se situa en el primer element de la seqüència mentre i ≤ n fer //La condició serà certa per a tots els elements entre i i n

fact := fact * i; //fact ( que conté el producte dels nombres tractats fins al moment) es multiplica pel valor que té i en aquesta seqüència.

i := i + 1; //Fem avançar la seqüència. fmentre {Post: n=N, N>0, fact és el factorial de i-1 i i=n + 1, per tant, fac és el factorial de N} escriureEnter(fact);falgorisme

DIVISOR D’UN NÚMERO (Esquema de recorregut)

Algorisme que donat un nombre enter positiu escrigui els divisors pel dispositiu de sortida. Sabem que un número és divisor d’un altre si aquesta divisió és exacta.

algorisme divisors var

n := enter;i := enter;

fvar n := llegirEnter ();{ Pre: n=N i N ≥0 } i := 2 mentre i < n fer

// Els divisors de n més petits que i s’han escrit pel dispositiu de sortidasi n mod i = 0 llavors //esbrinem si i és divisor de n

escriureEnter (i); //Si ho és, l’algorisme l’escriufsii := i + 1; // per a fer avançar la seqüència, incrementarem i

fmentre{ Post: la seqüència de tots els divisors de N s’ha escrit pel dispositiu de sortida }falgorisme

SUMA DE LES XIFRES D’UN NÚMERO (Esquema de recorregut)Donat un número enter, escriu pel dispositiu de sortida un altre número enter que correspongui a la suma de les xifres del primer. Exemple: si el nombre és 7463, l’algorisme escriurà 20 (7+4+6+3).

algorisme sumaDigits var

n, suma, d := enter; //n és el número que llegim, d és la variable que guarda el dígit a cada iteració. fvar n := llegirEnter ();{ Pre: n=N i N≥0 } d := n mod 10; //Es divideix per 10 per a calcular el mod. En la variable d es guarda cada iteració suma := 0; //La suma s’inicialitza a 0 mentre no (n=0) fer //no(n=0) podria ser n>0 o n≠0

suma := suma + d; //Aquí va sumant a cada iteración := n div 10; //Es divideix n per 10 per a eliminar el darrer dígitd := n mod 10; //Es busca el darrer dígit següent

fmentre escriureEnter (suma);{ Post: la suma dels dígits de N s’ha escrit pel dispositiu de sortida }falgorismeNOMBRES PRIMERS (Esquema de cerca)

Funció que determina si un nombre enter positiu és primer o no i retorna cert en cas afirmatiu i fals en cas contrari. Els nombres primers només poden ser dividits per la unitat i per ells mateixos.

funcio esPrimer (n: enter): boolea;{ Pre: n> 0 } var

trobat, primer: boolea;i: enter;

fvar i := 2; //Inicialitzarem i a 2 trobat := fals; mentre i < n i no trobat fer

si n mod i = 0 llavors //Cerquem un divisor de ntrobat := cert;

fsisi no trobat llavors //Si trobat és fals s’incrementa l’índex

i := i + 1;fsi

fmentre primer := no trobat; //El nombre és primer si no s’ha trobat cap divisor retorna primer;{ Post: primer és cert si n és primer i als en cas contrari }ffuncio

COMPTAR QUANTES VEGADES APAREIX LA LLETRA A (Recorregut aplicat a l’entrada)En una frase acabada amb un punt que s’introdueix pel teclat.

algorisme comptaLletraA var car: caracter; //reflecteix l’estat de la seqüència i conté el darrer element llegit que es

correspon amb el capçal de la seqüència. n: enter; //Conté el nombre de lletres ‘a’ que hi ha abans del capçal fvar car := llegirCaracter(); n := 0; mentre no car =’.’ fer si car = ‘a’ llavors n := n + 1; // Si troba una lletra ‘a’ incrementarem ‘n’ fsi car := llegirCaracter(); fmentre

escriureEnter();falgorismeTROBAR UNA LLETRA ‘A’ (Esquema de cerca aplicat a l’entrada)

És semblant a l’exemple anterior, però en aquest es resol amb una cerca perquè la seqüència no s’ha de continuar processant a partir del moment que es troba una lletra “a”.

algorisme surtLletraA var trobat: boolea; car: caracter; fvar

car := llegirCaracter(); trobat := fals; mentre no (car = '.' ) i no trobat fer

//Cap dels elements llegits anteriors a l’últim no és una lletra “a”. L’últim és a car trobat := car = 'a';

si no trobat llavors car := llegirCaracter();

fsi fmentre

// Si trobat és cert, car és una lletra “a”; si és fals, car és el punt finalsi trobat llavors escriureCaracter('S');sinó escriureCaracter('N');

fsifalgorisme

MITJANA ARITMÈTICA (Esquema de recorregut aplicat a l’entrada)Sèrie de nombres reals que es llegiran de l’entrada. Hi haurà almenys un nombre i tots els nombres són diferents de 0.0. Darrere de l’últim element de la sèrie hi haurà un 0.0.

algorisme mitjana var x, suma: real; //suma dels nombres n: enter; //comptador fvar x := llegirReal(); n := 0; suma := 0.0; mentre no (x = 0.0) fer suma := suma + x; n := n + 1; x := llegirReal(); fmentre escriureReal(sum/enterAREal(n));falgorisme

INDICAR SI UNA SÈRIE DE NOTES ESTÀ FORMADA EXCLUSIVAMENT PER APROVATS

(Esquema de cerca aplicat a l’entrada)Les notes “A”, “B”, “C” (C+) són aprovats i “c” (C-) i “D” són suspensos. Darrere l’últim element de la sèrie hi haurà una “Z”.

algorisme tothomAprova var

trobat: boolea;car: caracter;

fvar car := llegirCaracter(); trobat := fals; mentre no (car = “Z”) i no trobat fer

trobat := (car =’c’) o (car =’D’);si no trobat llavors car :=llegirCaracter();fsi

fmentre// Si trobat és cert, car és un suspens, si és fals car és “Z”si trobat llavors

escriureCaracter(‘N’);sinó

escriureCaracter(‘S’);fsi

falgorisme

NOTA MITJANA DE SUSPENSOS O 0.0 SI NO HI HA SUSPENSOS

(Combinació d’esquemes de recorregut i de cerca)Algorisme que llegeix una sèrie de notes entre 0.0 i 10.0, ordenada descendentment i marcada amb un -1.0. L’algorisme en dóna la nota mitjana dels suspensos o 0.0 si no hi ha suspensos. Un suspens és qualsevol nota inferior a 5.0.

algorisme mitjanaSuspensos var x, suma, resultat: real; // x és la nota que anem llegint, suma va sumant els suspesos i

resultat és el resultat final n: enter; // n és el comptador de suspesos trobat: boolea; fvar x := llegirReal(); trobat := fals; mentre no (x= -1.0) i no trobat fer trobat := x < 5.0 //perquè trobat sigui cert, ha de ser menor que 5.0 si no trobat llavors x := llegirReal(); fsi fmentre//cap de les notes llegides anterior a l’última no és un suspens. L’ultima és a x. Si trobat és cert, x és un suspens; si és fals, x és -1.0. n := 0; suma := 0.0; mentre no (x= -1.0) fer//suma = suma de tots els valors llegits a partir del primer suspens llevat de l’últim, que és la marca i n = nombre d’elements sumats. suma := suma + x ; n := n + 1 x := llegirReal(); fmentre

si n > 0 llavorsresultat := suma/enterAReal(n);

sinoresultat := 0.0;

fsiescriureReal(resultat);

falgorisme

LONGITUD DE LA PRIMERA PARAULA D’UNA ENTRADA

(Combinació d’esquemes de recorregut i de cerca)Si no hi ha cap paraula, la resposta és 0.

{ Pre: A l’entrada es llegeixen una seqüència de caràcters que no conté cap punt seguida d’un punt} longPrimPar{ Post: Escriu la longitud long de la primera paraula (seqüència de lletres majúscules seguides o 0 si no hi ha cap lletra}

algorisme longPrimPar var car: caracter; n: enter; // n és el nombre de lletres llegides trobat: boolea; fvarLLEGEIG CARÀCTERS FINS A TROBAR LA PRIMERA LLETRA DE LA PRIMERA PARAULA car := llegirCaracter(); trobat := fals; mentre no (car = ’.’) i no trobat fer trobat := (car ≤ ‘Z’) i (car ≥ ‘A’); //perquè trobat sigui cert, ha de ser un caràcter

contingut entre A i Z si no trobat llavors car := llegirCaracter(); fsi fmentre// cap dels caràcters llegits anteriors a l’últim no és una lletra. L’últim és a car. Si trobat és cert, car és una lletra; si és fals, car és el punt final.LLEGEIG CARÀCTERS FINS A TROBAR EL PRIMER SEPARADOR POSTERIOR A LA PRIMERA PARAULA I VA COMPTANT LES LLETRES LLEGIDES. –si no hi ha paraula, la primera cerca fracassa i la segona cerca acaba immediatament sense entrar en el bucle i deixa el comptador a 0. trobat := fals; n := 0; mentre no (car = ’.’) i no trobat fer trobat := (car ≤ ‘Z’) o (car ≥ ‘A’); si no trobat llavors

n := n + 1; car := llegirCaracter();

fsi fmentre// Si trobat és cert, car és un separador, si és fals, car és el punt final, n és el nombre de lletres llegides.

escriureEnter(n);falgorisme