Resum d'algorismes i problemes resolts. Assignatura de Programació del Grau Multimèdia de la UOC.

1. CONSTANTS
const
const
nomConstant1 : tipus = valorConstant1;
N: enter = 100;
nomConstant2 : tipus = valorConstant2;
fconst
...
fconst
TIPUS
tipus
color = {verd, blau, vermell groc, blanc};
dia = {dilluns, dimarts, dimecres, dijous};
mes = {gener, febrer, març, abril, maig};
ftipus
VARIABLES
var var
nomVariable1 : tipusVariable1; t: taula(N) de enter;
nomVariable2 : tipusVariable2; i, n: enter;
... fvar
fvar
COMPOSICIÓ ALTERNATIVA
siexpressiollavors sin > 0llavors
accioa accio1
sino sino
acciob accio2
fsi fsi
COMPOSICIÓ ITERATIVA
index := valor inicial;
per index := valor inicial fins valor final [pas increment]
mentreindex ≤ valor final fer
acció;
accio;
fper
index := index + increment;
fmentre

2. ACCIONS
DECLARACIÓ: DECLARACIÓ:
acciónom(param1, param2, ... , paramn) acciósuma(ent x: enter, sor y: enter, entsor z: enter)
... cos de l’acció ... cos de l’acció
facció facció
ASSIGNACIÓ: ASSIGNACIÓ:
nom de l’acció (obj1, obj2, ... , objn) suma (x,y,z)
ACCIONS PREDEFINIDES
accioescriureEnter (ent e: enter) Acció que visualitza per pantalla el valor de l’enter e
accioescriureReal (ent r: real) Acció que visualitza per pantalla el valor del real r
accioescriureCaracter(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 aplicant una acció:
accio intercanvia (entsor x: enter, entsor y: enter)
Exemple d’algorisme sense acció:
var
aux: enter;
{Pre: (x=X i y=Y) i (z=Z i w=W) i (v=V i u=U) }
fvar
aux := x; aux := x;
x := y; x := y;
y := aux; y := aux;
aux:= z; facció
z := w; Podríem invocar l’acció en l’algorisme:
w := aux;
aux := v; algorisme intercanviarValors
v := u; {Pre: (x=X i y=Y) i (z=Z i w=W) i (v=V i u=U) }
u := aux; intercanvia(x,y);
intercanvia(z,w);
{ Post: (x=Y i y=X) i (z=W i w=Z) i (v=U i u=V) } intercanvia(u,v);
{ Post: (x=Y i y=X) i (z=W i w=Z) i (v=U i u=V) }
falgorisme

3. FUNCIONS
funció nom(param1, param2, ... , paramn): tipus funcioesPrimer (n: enter): booleà
... ...
retornaexpressio; retorna primer;
ffuncio ffuncio
FUNCIONS PREDEFINIDES
funciorealAEnter(x: real): enter
funcioenterAREal(x: enter): real
Funcions de conversió de tipus
funciocaracterACodi(x: caràcter): enter
funciocodiACaracter(x: enter): caracter
Funció que retorna un enter introduït pel teclat del
funciollegirEnter():enter
computador
Funció que retorna un caracter que ha estat introduït
funciollegirCaracter():caracter
pel teclat del computador
Funció que retorna un real que ha estat introduït pel
funciollegirReal():real
teclat del computador

4. ESQUEMA DE RECORREGUT D’UNA SEQÜÈNCIA
algorismeesquemaRecorregut
var
element: tipus;
fvar
element := llegir();
inici tractament
mentrenofi sequenciafer(mentre no (element = marca) fer)
tractar element
avançar sequencia
element := llegir();
fmentre
tractament final
falgorisme
ESQUEMA DE CERCA D’UNA SEQÜÈNCIA
algorismeesquemaCerca
var
trobat: boolea;
element : tipus;
fvar
element := llegir();
trobat := fals;
mentrenofi sequenciai 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 final
falgorisme

5. TAULES
var var
nom: taula[mida] detipus; recaptacioCinema: taula[7] deenter;
fvar fvar
OPERACIONS ELEMENTALS
Si tenim la taula
var podrem fer:
t:taula[10] de enter; t[3] Accedim a l’element de tercera posició
fvar
Si tenim la taula podrem fer:
var aparicions[1] fa referència al primer element de la taula,
aparicions: taula[26] de enter; aparicions[2] al segon, aparicions[3] al tercer i així
fvar successivament.
ASSIGNACIÓ D’UNA TAULA
t[5] := 11;
LECTURA I ESCRIPTURA
Escriu en el dispositiu de sortida el valor contingut en el posició 2
escriureEnter(t[2])
de la taula “t”.
escriureEnter(t) No té sentit. Provocaria Error
Llegeix una dada del dispositiu d’entrada i l’assigna a la posició 4
t[14] := llegirEnter()
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;
fvar
Per assignar una recaptació de 84, el divendres, a
la sala 2:
recaptacioCinema[5,2] := 84;
declaració:
var
recaptacioCinema: taula[7] de taula [3] de enter;
fvar
Assignació:
recaptacioCinema[5][2] := 84;

6. TUPLES
tipus
proveidor: tupla
nom: taula[15]de caracter;
telefon, fax: enter;
ftupla
ftipus
var
proveidor1, proveidor2: proveïdor;
fvar
OPERACIONS ELEMENTALS
ACCÉS CORRECTE ACCÉS INCORRECTE
nom[1] {No es pot fer referència al camp sense
proveidor1.nom[1] {1er caràcter del camp nom indicar el nom de la tupla}
de la tuplaproveidor1} proveïdor.telefon{No es pot fer servir el tipus
proveidor2.telefon proveïdor com si for una variable}
proveidor1.fax fax.proveidor1 {primer ha d’anar el nom de la
tupla i després el nom del camp}
ASSIGNACIÓ
proveidor1.telefon := 935847259;
proveidor2.telefon := 934528632;
LECTURA I ESCRIPTURA
a.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
tipus
llistaMes = {gener, febrer, març, abril,
nota = {N, D, C, B, A};
maig, juny, juliol, agost,
alumne = tupla
setembre, octubre,
codiMatricula: enter;
novembre, desembre};
nom: taula [25] decaracter;
data = tupla
adreçaE: taula[40]decaracter;
dia: enter;
notesPAC: taula[5] de nota;
mes: llistaMes;
qualificació: nota;
any: enter;
ftupla
ftupla
ftipus
ftipus

7. 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ÚMERO
El 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

8. 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 sortida
si n mod i = 0 llavors //esbrinem si i és divisor de n
escriureEnter (i); //Si ho és, l’algorisme l’escriu
fsi
i := 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).
algorismesumaDigits
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
mentreno (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ígit
d := 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 }
falgorisme

9. NOMBRES 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.
funcioesPrimer (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 n
trobat := cert;
fsi
sino 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.
algorismecomptaLletraA
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;
mentreno car =’.’ fer
si car = ‘a’ llavors
n := n + 1; // Si troba una lletra ‘a’ incrementarem ‘n’
fsi
car := llegirCaracter();
fmentre
escriureEnter();
falgorisme

10. TROBAR 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”.
algorismesurtLletraA
var
trobat: boolea;
car: caracter;
fvar
car := llegirCaracter();
trobat := fals;
mentreno (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 final
si trobat llavors
escriureCaracter('S');
sinó
escriureCaracter('N');
fsi
falgorisme
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

11. 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”.
algorismetothomAprova
var
trobat: boolea;
car: caracter;
fvar
car := llegirCaracter();
trobat := fals;
mentre no (car = “Z”) ino 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

12. 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.
algorismemitjanaSuspensos
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) ino 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 llavors
resultat := suma/enterAReal(n);
sino
resultat := 0.0;
fsi
escriureReal(resultat);
falgorisme

13. 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}
algorismelongPrimPar
var
car: caracter;
n: enter; // n és el nombre de lletres llegides
trobat: boolea;
fvar
LLEGEIG CARÀCTERS FINS A TROBAR LA PRIMERA LLETRA DE LA PRIMERA PARAULA
car := llegirCaracter();
trobat := fals;
mentre no (car = ’.’) ino 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 = ’.’) ino 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