M3 - UF1 - T2

Generalitat de Catalunya Departament d’Educació Institut Almatà de Balaguer

Tècnic superior en Desenvolupament d’Aplicacions Multiplataforma (DAM) Tècnic superior en Desenvolupament d’Aplicacions Web (DAW) CFGS - 1r – DAM-DAW

CFGS - 1r – DAM_DAW - M3 - UF1 – T2 Material fet per APM. Pàgina 1/51

Continguts: M3 - UF1 – T2 UF1. Programació estructurada.

2. Tipus de dades simples i compostes. Programació estructurada.

2.1. Fonaments de programació.

2.2. Introducció a l’algorísmica.

2.3. Disseny d’algorismes.

2.4. Prova de programes.

2.5. L’assignació.**

2.6. Lectura i escriptura del canal d’entrada i sortida respectivament.**

2.7. Estructures de selecció o condicionals.

2.8. Estructures de repetició o iteratives.

2.9. Sentències de trencament de seqüència o salt.

2.10. Tipus de dades Enumerades.**

2.11. Subtipus de dades en algorísmica.

2.12. Tipus de dades compostes (cadenes, taules i tuples).*

2.13. Tractament de cadenes.

2.14. Gestió de taules: tractament seqüencial, ordenació, cerca dicotòmica,

inserció ordenada.

2.15. Depuració d’errors. (pràctica a classe)

2.16. Documentació dels programes. (fet al Tema 1)

2.17. Entorns de desenvolupament de programes. (fet al Tema 1)

2.18. Esquemes algorísmics. Esquema de recorregut i cerca per una

seqüència. **

*Aquest apartat no segueix l’ordre d’exposició.

**Aquest/s apartat/s s’han afegit respecte el temari oficial.




2. Tipus de dades simples i compostes. Programació estructurada.

Objectius

2. Utilitza correctament tipus de dades simples i compostes emprant les

estructures de control adients.

2.1. Descriu els fonaments de la programació

2.2. Escriu algorismes simples.

2.3. Analitza i dissenya els possibles algorismes per la resolució de

problemes.

2.4. Escriu i prova programes senzills reconeixent i aplica els fonaments de

la programació.

2.5. Utilitza estructures de dades simples i compostes.

2.6. Escriu i prova codi que faci ús de les estructures de selecció.

2.7. Utilitza correctament les diferents estructures de repetició disponibles .

2.8. Reconeix les possibilitats de les sentències de salt.

2.9. Realitza operacions bàsiques, compostes i de tractament de caràcters.

2.10. Realitza operacions bàsiques sobre taules de dades simples i de dades

compostes.

2.11. Revisa i corregeix els errors apareguts en els programes.

2.12. Comentat i documenta adequadament els programes realitzats.

2.13. Utilitza un entorn integrat de desenvolupament en la creació i

compilació de programes simples.




2.1 Fonaments de programació.

Podem definir un programa com la codificació d’un algorisme fent servir un

llenguatge de programació.

Els computadors entenen el llenguatge en que s’escriuen els programes.

D’aquesta forma els programes són executables per les computadores.

Un computador és una maquina electrònica capaç d’executar un programa

emmagatzemat.

Quins problemes es poden resoldre amb un computador?

Els problemes de càlcul on a partir d'unes dades d'entrada, es calculen altres

dades anomenades de sortida.

dades entrada _ ordinador controlat per programes _ dades sortida (resultats)

Exemples d'enunciats de problemes típics:

• Donada una llista de números, calcular quin és el màxim.

• Donat un número real, calcular la seva arrel cúbica.

• Trobar les soluciones d’un sistema d’equacions.

• Donat un numero de DNI, calcular la seva lletra del NIF.




2.2 Introducció a l’algorísmica. Expressions.

Taula Recordatori.

“Un algorisme és una forma de comunicar procediments de càlcul a

interlocutors humans. Quan codifiquem un algorisme obtenim un programa. Un

programa és una forma d’expressar procediments de càlcul executables per un

computador.”

Algorisme: descripció precisa de la successió d'accions (instruccions, càlculs)

que resolen un problema.

Els algorismes són tan antics com l’home en la seva necessitat de

comunicar com es poden fer determinades tasques.

Els algorismes s’escriuen en un llenguatge pensat per interlocutors

humans.

Per executar un algorisme no cal un computador. Un algorisme pot ser

executat per qualsevol persona que entengui el llenguatge en que està

escrit.

Malauradament els humans som massa lents fent càlculs complicats i sovint ens equivoquem...

Programa: codificació d'un algorisme fent servir un llenguatge de

programació.

Els programes van aparèixer amb les primeres màquines programables

(computadors).

Els programes s’escriuen en el llenguatge que entén el computador.

Per executar un programa cal un computador.

Computador: màquina electrònica capaç d’executar un programa emmagatzemat.




2.3 Disseny d’algorismes.

2.4 Prova de programes.

Com podem especificar què ha de fer un algorisme?

Com ja hem dit, un algorisme és simplement una successió d’accions, on cada

acció provoca un canvi en l’estat de l’algorisme (és a dir, modifica el valor

d’alguna variable).

Per tant, el més important d’un algorisme en quant a la seva especificació és

que, després de la seva execució, determinades variables (les que contindran

el resultat) tinguin els valors esperats. Per això en tota especificació cal

determinar quines són les variables amb dades d’entrada i quines són les

variables amb resultats, ja que les farem servir per expressar tant les

condicions sobre les dades d’entrada (domini del problema) com les

condicions sobre les dades de sortida (resultats).

Elements d’una especificació

La especificació d’un algorisme consta de 4 elements, en aquest ordre:

Declaració de variables: nom (a,b, mcd) i tipus (enter, real, caràcter,

booleà) de les variables que són significatives a priori (dades d’entrada i

resultats esperats).

Precondició: condició que ha de complir l’estat inicial de l’algorisme

(condicions sobre les dades d’entrada, és a dir, domini de l’algorisme).

Nom de l'algorisme que estem especificant.

Postcondició: condició que ha de complir l’estat final (quin és el resultat

d'executar l'algorisme).

Fixeu-vos que tan la precondició com la postcondició fan referència a estats de

l’algorisme (és a dir, als valors de les seves variables).




Etapes de desenvolupament d’un programa

El desenvolupament d’un programa és un procés en que es parteix de

l’enunciat d’un problema, i s’obté un programa executable que el soluciona.

Les etapes del desenvolupament d'un programa són les següents:

Etapa 1: Formalització de l’enunciat.

Objectiu: Obtenir una descripció precisa del problema en quant a quines són

les dades d'entrada i quins són els resultats esperats. Normalment el punt de

partida és l’enunciat del problema que es vol resoldre, expressat sovint en

llenguatge natural. Una bona forma d’assegurar que hem entès l’enunciat

correctament és expressar-lo en un llenguatge formal. El llenguatge que

s’acostuma a triar és el càlcul de predicats.

Resultat: Especificació de l’algorisme.

Llenguatge usat pel resultat: llenguatge formal (càlcul de predicats).

Etapa 2: Disseny de l’algorisme.

Objectiu: passar de l'especificació d'un problema a l'algorisme que porta a la

seva solució. És una part de programació que es pot fer amb llapis i paper.

Resultat: Algorisme.

Llenguatge usat per resultat: llenguatge algorísmic, destinat a les persones.

Etapa 3: Implementació.

Objectiu: obtenir, a partir de l’algorisme, un programa en un llenguatge de

programació d’alt nivell, com ara C o Pascal.

Resultat: Fitxer amb el programa font.

Llenguatge usat pel resultat: Un llenguatge de programació d’alt nivell.

Aplicació informàtica que farem servir: Editor de textos (emacs, notepad, etc)

Etapa 4: Compilació.

Objectiu: Traducció del programa font (programa escrit en llenguatge d’alt

nivell) en un programa executable (programa en llenguatge màquina).

Resultat: Programa executable.

Llenguatge usat pel resultat: Llenguatge màquina, un llenguatge que controla

directament els components electrònics de la CPU.

Aplicació informàtica que farem servir: compilador de C




Etapa 5: Execució i Prova

Objectiu: Provar el programa resultant amb diferents dades d’entrada (joc de

proves), tractant de verificar si és correcte. Malauradament, els jocs de proves

només serveixen per detectar si un programa no és correcte, però no per

assegurar que sí ho és (llevat que es comprovin totes les entrades possibles,

que és pràcticament impossible).

Aplicació informàtica que farem servir: el sistema operatiu, per executar el

programa.

A cada etapa es fa servir un llenguatge diferent !

El disseny d’algorismes el farem en hores de teoria. La implementació,

compilació i prova ho farem en hores de laboratori.

Exemple de resolució d’un problema amb un computador: càlcul del mcd.

L'algorisme d'Euclides és un mètode per calcular el màxim comú divisor que té

més de 2500 anys d'antiguitat.

Ara veurem totes les etapes per resoldre el càlcul del mcd. Només es pretén

facilitar un exemple de les diferents etapes, no importa que ara no s’entengui

el codi.

Enunciat del problema (en llenguatge natural)

Donats dos números enters a i b, calcular el seu mcd.

Algorisme o procediment de càlcul proposat:

En notació informal:

Restar al nombre més gran el més petit fins que els dos nombres siguin

iguals; aquesta és la solució.




En notació per passos numerats:

1. Mireu si a i b són iguals. Si és així, aquest valor és la solució i hem

acabat.

2. Si a és més gran que b, llavors resteu-li b.

3. Si b és més gran que a, llavors resteu-li a.

4. Tornar al pas 1.

Exemple d'especificació una mica formal

{ Pre: a=A, b=B, A>0, B>0 }

algorisme euclides

{ Post: a=b i a=mcd(A,B) }

En la notació algorísmica (no cal entendre’l ara):

algorisme euclides

var

a, b : enter

fvar

a:=LlegirEnter()

b:=LlegirEnter()

mentre a ≠ b fer

si a>b aleshores a:=a-b fsi

si a<b aleshores b:=b-a fsi

fmentre

falgorisme

Programa (en llenguatge C, no cal entendre’l ara).

#include “c3DAM.h” //llibreria personal

void main(void)

{

int a,b;

a=llegirEnter(); //funció de llibreria

b=llegirEnter();

while ( a!=b )

{

if ( a>b ) a= a-b;

if ( a<b ) b= b-a;

}

escriureEnter(a); //funció de llibreria

}




Un apunt sobre “l’aparença” dels programes...

En els darrers anys, l’esforç per fer que els ordinadors siguin més fàcils d’usar

ha fet que es doni molta importància a les interfícies d’usuari dels programes,

que és la part “visible” d’una aplicació informàtica. Actualment la majoria

d’aplicacions disposen d’interfícies gràfiques molt atractives, basades en

elements intuïtius com ara finestres, menús, i icones. El disseny d’interfícies

gràfiques està fora de l’abast d’aquest curs, per la qual cosa els programes

que desenvoluparem rebran les dades preferentment del teclat i mostraran els

resultats per pantalla en forma textual. Encara que el resultat és visiblement

menys “atractiu” que amb una interfície gràfica, l’absència d’aquests elements

accessoris ens permetrà concentrar-nos en la part més de càlcul dels

programes, que és la més important. A segon curs veureu com fer el disseny

d’interfícies gràfiques.

Exemple:

Implementació de l’algorisme d’Euclides amb una interfície textual (la que

farem servir):

Implementació de l’algorisme d’Euclides amb una interfície gràfica:




2.5 L’assignació.

L’assignació és l’acció fonamental a partir de la qual es construeixen els algorismes. L’execució d’una assignació consisteix a avaluar una expressió i a emmagatzemar el resultat en una variable.

Sintaxi de l’assignació en llenguatge algorísmic

nomVariable := expressió

on:

nomVariable és el nom d’una variable que haurem declarat prèviament;

expressió és una expressió vàlida on totes les constants que conté

estan definides i totes les variables que conté estan declarades i

inicialitzades.

El simbol ‘:=’ s’anomena símbol de l’assignació, i es llegeix “...pren per valor...”.

Exemple:

Mitja := suma / n

Validesa

Al costat dret hi ha d’haver una expressió vàlida (totes les variables han d’haver estat declarades i inicialitzades prèviament).

El tipus de l’expressió i de la variable han de coincidir (enter i enter, real i real, booleà i booleà, etc.).

Execució d’una assignació Una assignació s’executa en dos passos: 1. S’avalua l’expressió del costat dret (tasca duta a terme per la unitat

aritmètica i lògica). 2. El resultat s’emmagatzema dins la variable de la part esquerra. (escriptura a

memòria). Observeu que l’execució d’una assignació implica:

Una operació de lectura (consulta) per cadascuna de les variables que apareixen a l’expressió.

Una operació d’escriptura (modificació) de la variable de l’esquerra de l’assignació.

Exemple: intercanvi de dues variables (exercici de laboratori).




2.6 Lectura i escriptura del canal d’entrada i sortida respectivament.** Lectura de dades del canal d’entrada El llenguatge algorísmic està dotat de quatre funcions predefinides que permeten llegir dades del canal d’entrada estàndard. Habitualment el canal d’entrada és el teclat, per tant aquestes funcions permeten demanar l’entrada de dades a l’usuari (ja siguin dades enteres, reals o caràcters). Aquestes tres funcions són LlegirEnter, LlegirReal i LlegirCaracter, LlegirParaula() i el seu format és:

nomVariable := LlegirEnter()

nomVariable := LlegirReal()

nomVariable := LlegirCaracter()

nomVariable := LlegirParaula()

L’execució d’aquestes assignacions sobre el teclat es duu a terme així: 1. L’ordinador espera fins que l’usuari entri una dada. 2. Si la dada entrada no és del tipus demanat (enter, real, caràcter, paraula),

es considera un error. 3. Si la dada entrada és del tipus demanat, es copia aquest valor dins la

variable. Notes:

Hi ha un nou tipus de dades estructurat que anomenarem paraula. Aquest nou tipus pot contenir un conjunt de caràcters.

El contingut d’una variable de tipus paraula sempre acabarà amb un caràcter nul o ‘\0’.

L’entrada de la funció LlegirParaula() s’acaba quan es prem per teclat la tecla return.




Escriptura de dades pel canal de sortida. El llenguatge algorísmic també està dotat de quatre accions predefinides que permeten escriure dades al canal de sortida estàndard (normalment el canal de sortida és la pantalla, per tant, aquestes operacions escriuen per pantalla): EscriureEnter Format: EscriureEnter(expressió entera) Resultat: Escriu pel canal de sortida el valor d’una expressió de tipus enter. Exemples: EscriureEnter(25), EscriureEnter(a+5) EscriureReal

Format: EscriureReal(expressió real) Resultat: Escriu pel canal de sortida el valor d’una expressió de tipus real Exemples: EscriureReal(25.2), EscriureReal(r/2.0)

EscriureCaracter

Format: EscriureEnter(expressió de tipus caràcter) Resultat: Escriu pel canal de sortida el valor d’una expressió de tipus

caràcter. Donat que els caràcters no tenen cap operació interna, una expressió de tipus caràcter només pot ser o bé un valor (ex. ‘a’), o bé el nom d’una variable de tipus caràcter.

Exemples:

const C : caracter = ‘Z’

fconst EscriureCaracter(C) //escriu per pantalla una Z EscriureCaracter(‘C’) //escriu per pantalla una C

EscriureParaula Format: EscriureParaula(“cadena de text”) Resultat: Escriu pel canal de sortida la cadena de text delimitada per

cometes dobles. Acaba d’escriure a pantalla quan troba el caràcter o marca de final de paraula ‘\0’.

Exemple: EscriureParaula(“Entra un enter:”)




2.7 Estructures de selecció o condicionals. L’estructura SI. Fins ara només hem vist l’estructura seqüencial. Aquesta estructura permet executar una acció rere l’altra de forma consecutiva i seqüencial. Exemple: acció 1 acció 2 ... Com ara, a := 1; b := 2; escriuEnter(A); ... Si ens hi fixem bé, és fàcil adonar-se que aquesta estructura no es suficient per solucionar determinats problemes. Suposem que tenim dos variables amb de tipus enter inicialitzades amb un determinat valor de tipus enter: a, b: enter; a:=5; b:=7; Arribats en aquest punt ens interessa saber quin dels dos valors és el més gran. Podem fer-ho amb l’estructura seqüencial? Evidentment no. No tenim cap manera de formular preguntes del tipus ‘a>b’ Per tant, no podem saber quin dels dos valors és el més gran. Necessitem doncs una nova estructura que ens permeti formular preguntes i en funció de la resposta ens deixi triar alternativament quina serà la següent acció a executar del nostre codi. Aquesta estructura s’anomena estructura de selecció o condicional i s’anomena si. Així doncs, l’estructura condicional permet que algunes accions s’executin només quan es compleix una determinada condició. Per tant, permet prendre decisions i seguir camins alternatius dins un algorisme.




Sintaxi de l’estructura condicional simple en llenguatge algorísmic

si condicio llavors accio1 ... accion

fsi

on: condicio és una expressió vàlida que dóna com a resultat un booleà acció és qualsevol acció o conjunt d’accions vàlides (assignació o altres estructures de control).

Exemple:

si a>b maxim:=a

fsi si a<=b

maxim:=b

fsi

Una estructura si s’executa en tres passos: 1. S'avala la condició i s’identifica si és certa 2. S’executen les accions corresponents a la condició que ha resultat ser

certa. 3. Continua l’execució de l’algorisme per la línia següent al fsi Validesa Perquè aquesta estructura sigui vàlida, s’han de seguir aquestes regles:

La condició ha d’estar ben construïda i avaluar a cert o fals. Altrament seria erroni i no s’executarien mai les accions del condicional o bé el resultat seria imprevisible.




Sintaxi de l’estructura condicional composta en llenguatge algorísmic

si condicio llavors

accioSi1 ... accioSin

sino

accioSino1 ... accioSinon

fsi

Una estructura si..sino s’executa de la següent forma: 1. S'avala la condició i s’identifica si és certa

1.1. Si és certa s’executen les accionsSi corresponents a la condició que ha resultat ser certa. En acabar d’executar l’accióSin continua l’execució de l’algorisme per la línia següent al fsi.

1.2. Si no és certa s’executen les accionsSino del bloc sino. En acabar d’executar l’accióSinon continua l’execució de l’algorisme per la línia següent al fsi.

Cal adonar-se que sempre s’executarà un dels dos blocs d’accions.

Exemple: Càlcul del màxim de 3 números, etc. (exercici de laboratori)

L’estructura CASOS.

L’estructura condicional casos permet definir cada cas en funció d’un conjunt de valors en què s’ha de situar el resultat d’una expressió definida a l’inici de la estructura.

La sintaxi en pseudocodi és:

casos <expressió> cas<conjunt_de_valors_1>: <conjunt_d'instruccions_1> cas <conjunt_de_valors_2>: <conjunt_d'instruccions_2> ... cas <conjunt_de_valors_3>: <conjunt_d'instruccions_3> [altrament: <conjunt_d'instruccions>]

fcasos




Quan s’executa una instrucció casos, el programa executa l’expressió que dóna un resultat d’algun tipus conegut pel llenguatge; posteriorment, el programa compara aquest resultat amb els diferents conjunts de valors fins a trobar-ne un que contingui el resultat calculat inicialment; en aquest moment, executa el conjunt d’instruccions que acompanya el conjunt de valors i, posteriorment, continua l’execució per la instrucció posterior a la paraula reservada fcasos. S’atura en el primer conjunt de valors que inclou el resultat. Si posteriorment n’hi ha d’altres, no se n’assabenta. El cas altrament s’executa si cap conjunt de valors no inclou el resultat calculat. Si cap conjunt de valors no conté el resultat i no hi ha altrament, s’executa la instrucció següent a la paraula reservada fcasos.

La següent figura mostra la representació d’aquesta estructura en ordinograma i consisteix en una generalització de l’estructura seqüencial doble on els camins de sortida poden ser més de dos i de tipus no lògic.

Cada camí de sortida correspon a un dels conjunts de valors especificats en els diferents apartats cas de l’estructura.

Els conjunts de valors es poden especificar de diferents maneres:

valor únic;

llista de valors (separats per comes: ‘A’, ‘E’, ‘I’, ‘O’, ‘U’);

interval de valors (des de l’inici fins al final separats per ..: ‘a’..’z’).

Nota: La traducció d’aquesta estructura a llenguatge C la

trobareu a l’espai de laboratori.




Exemples:

1. Volem fer un programa que faciliti la traducció del mes numèric a mes en lletres (1 per a gener, 2 per a febrer, etc.).

algorisme traducció_mes_1 és

var mes: enter;

fvar netejarPantalla(); escriureParaula ("Introdueixi el número de mes a traduir, si us plau:"); llegirEnter (mes); saltarLinia(); casos mes

cas 1: escriureParaula ("Traducció: Gener"); cas 2: escriureParaula ("Traducció: Febrer"); cas 3: escriureParaula ("Traducció: Març"); cas 4: escriureParaula ("Traducció: Abril"); cas 5: escriureParaula ("Traducció: Maig"); cas 6: escriureParaula ("Traducció: Juny"); cas 7: escriureParaula ("Traducció: Juliol"); cas 8: escriureParaula ("Traducció: Agost"); cas 9: escriureParaula ("Traducció: Setembre"); cas 10: escriureParaula ("Traducció: Octubre"); cas 11: escriureParaula ("Traducció: Novembre"); cas12: escriureParaula ("Traducció: Desembre"); altrament: escriureParaula ("No existeix un mes amb número ",mes);

fcasos saltarLinia();

falgorisme

L’estructura casos avalua la variable mes. Segons el valor que tingui aquesta variable passarà directament al cas en qüestió. Per exemple, si la variable mes pren per valor 10, escriurà per pantalla “Traducció: Octubre”. Després sortirà de l’estructura casos i continuarà executant el codi de forma seqüencial.

Nota: Hem utilitzat un mètode anomenat “saltarLinia()” per indicar en pseudocodi que volem deixar una línia en blanc a la pantalla. De la mateixa forma hem utilitzat un mètode anomenat “netejarPantalla()” per indicar que volem netejar la pantalla.




2. Volem un programa que ens digui quants dies té un mes introduït per l’usuari. Suposarem per simplificar que febrer té 28 dies. algorisme dies_del_mes_1 és

var mes, any: enter;

fvar netejarPantalla; escriureParaula ("Introdueixi el número de mes, si us plau:"); llegirEnter (mes); saltarLinia; casos mes

cas 1: cas 3: cas 5: cas 7: cas 8: cas 10: cas 12 :escriureParaula ("Té 31 dies"); cas 4: cas 6: cas 9: cas 11 : escriureParaula ("Té 30 dies"); cas 2 : escriureParaula ("Té 28 dies”); altrament: escriureParaula ("No existeix un mes amb número ",mes);

fcasos saltarLinia;

falgorisme

Exemple: Si la variable mes pren per valor 1 o 3 o 5 o 7 o 8 o 10 o 12 imprimirà per pantalla “Té 31 dies”. Després sortirà de l’estructura casos i seguirà executant el codi de forma seqüencial. Exercici de laboratori: reproduir aquest algorisme utilitzant l’estructura si..sino en comptes de l’estructura casos




2.8 Estructures de repetició o iteratives. Introducció. Les estructures iteratives també se les coneixen amb el nom de “bucles”. Hi ha determinats problemes que amb les estructures que hem vist fins ara no podem resoldre’ls. Això ja ens va passar, si ho recordeu, quan només coneixíem l’estructura seqüencial i varem introduir l’estructura alternativa. Anem a veure quin tipus de problema no podem solucionar amb les estructures que coneixem, seqüencial i alternativa, i com aquesta nova estructura ens ho resoldrà. Exemple: Se’ns demana mostrar per pantalla els n primers termes de la successió de Fibonacci. Podem resoldre aquest problema amb les estructures que coneixem fins ara? La resposta és evidentment, No. Perquè? Encara que sabéssim calcular els termes de la successió de Fibonacci ens faltaria saber quants termes hem de fer sortir a pantalla. Dit d’una altra forma, quantes instruccions escriureEnter() posaríeu al vostre algorisme? Sembla el peix que es mossega la cua. Abans d’executar el codi no sabem quants termes de la successió ens demanarà l’usuari. Un cop executat el codi, per tant l’usuari, ja ens ha informat de quants termes voldrà (n) però, en aquell moment, no puc afegir cap instrucció nova al codi. Aquells problemes en els quals un boci de codi s’ha d’executar mentre es compleixi una determinada expressió booleana, es resoldran mitjançant iteracions. Fixeu-vos que el problema que havíem plantejat, a l’exemple, pertany a aquests tipus de problemes. Podem trobar una expressió booleana que ens diu quants cops hem de mostrar termes de la successió per pantalla. L’expressió en qüestió seria: “ repetir imprimir a pantalla termes de la successió de Fibonacci mentre el nombre de termes impresos sigui més petit o igual que n ”.




Tipus d’iteracions. Hi ha bàsicament tres tipus d’estructures iteratives:

El mentre

El per

El repetir 2.8.1 L’estructura mentre. Aquesta estructura iterativa permet executar, repetidament, un conjunt d’accions fins que s’arribi a una determinada condició.

Sintaxi de l’estructura iterativa en llenguatge algorísmic mentre condicio fer accio1 ... accion fmentre on: condicio és una expressió vàlida que dóna com a resultat un booleà. accio és qualsevol acció o conjunt d’accions vàlides que s’anomenen “cos del bucle o iteració”. Exemple

a:=1; mentre a<5 fer

escriureEnter(a); a:=a+1;

fmentre

Observeu que l’execució de l’exemple anterior escriuria per pantalla els valors 1, 2, 3 i 4.




Execució d’una estructura iterativa Una estructura mentre s’executa en tres passos:

1. S'avalua la condició de continuació. 2. Si és certa, s’executen totes les accions del cos del bucle i tornem al pas

1. 3. Si és falsa, sortim del bucle i continua l’execució de l’algorisme per la

línia següent al fmentre

Observeu que si al començament del bucle la condició és falsa, no s'executa el cos del bucle cap vegada. Validesa Perquè aquesta estructura sigui vàlida, s’han de seguir aquestes regles:

La condicio ha de posar-se de forma que es faci falsa després d’un determinat número d’iteracions. Això implica que la condició ha de contenir variables, i que el valor, com a mínim, d’una d’aquestes variables s’haurà d’alterar dins el bucle.

Exemples: Càlcul de productes, potències, factorial.

2.8.2 L’estructura per. Aquesta estructura també permet executar repetidament un conjunt d’accions. De fet, és un cas particular de mentre, en el que sabem a priori el número d’iteracions que cal fer.

Sintaxi de l’estructura iterativa en llenguatge algorísmic per variable en [inici..fi] fer accio1 ... accion fper on: variable és una variable declarada com enter, peró que no cal que hagi estat inicialitzada abans. inici i fi són enters o expressions que dónen com a resultat un enter.




accio és qualsevol acció o conjunt d’accions vàlides (assignació o altres estructures de control). Les accions dins d’un mentre s’anomenen “cos del bucle”. Exemple

per a en [1..4] fer escriureEnter(a);

fper

Observeu que l’execució de l’exemple anterior escriuria per pantalla els valors 1, 2, 3 i 4. Execució d’una estructura iterativa Una estructura per es defineix en termes del seu equivalent amb un mentre:

per variable en [inici..fi]

accions

fper

equival

a

variable:=inici

mentre variable<=fi fer accions

variable:=variable+1

fmentre

Observeu que:

si abans del per es compleix que inici=fi, llavors el cos del bucle només s’executa una vegada (només es fa una iteració).

si abans del per es compleix que inici>fi, llavors el cos del bucle no s’executa cap vegada.

Exemple: Càlcul de productes, potències, factorial. 2.8.3 L’estructura repetir. Aquesta estructura també permet executar repetidament un conjunt d’accions. S’utilitza en aquells casos en els quals no sabem a priori el número d’iteracions que cal fer, però sabem que almenys el cos de la iteració s’executarà un cop.




Sintaxi de l’estructura iterativa en llenguatge algorísmic repetir accio1 ... accion finsque ( condicio ); Les accions es repetiran fins que és compleix la condició. Fixeu-vos que com a mínim s’executaran un cop les accions del cos de la iteració. on: condicio és una expressió vàlida que dóna com a resultat un booleà. accio és qualsevol acció o conjunt d’accions vàlides que s’anomenen “cos del bucle o iteració”. Exemple

a:=1; repetir

escriureEnter(a); a:=a+1;

finsque(a≥5);

Observeu que l’execució de l’exemple anterior escriuria per pantalla els valors 1, 2, 3 i 4. L’estructura repetir no té una traducció directa a l’estructura mentre, però, sempre podrem trobar una estructura mentre equivalent a una estructura repetir concreta. Resumint l’ús de les iteracions. Ús de l’estructura mentre: podem utilitzar-la en tots els casos. Ús de l’estructura per: s’utilitza quan sabem el nombre de vegades que hem d’iterar. Ús de l’estructura finsque: s’utilitza quan, com a mínim, el cos de la iteració cal executar-la una vegada. Nota: tot i que sempre podrem utilitzar l’estructura mentre, hi ha casos en els quals serà millor utilitzar una de les altres dues estructures (per i finsque). En aquests casos el codi quedarà més compacte, o amb menys instruccions, i generalment més clar.




2.9 Sentències de trencament de seqüència o salt. Es tracta de sentències que trenquen amb la seqüència esperada d’execució del codi. Hi ha tres quatre sentències de trencament:

Trencar;

Continuar;

Retorna(estat);

Saltar etiqueta; Trencar. Trencar s’utilitza per sortir d’una estructura sense haver acabat d’executar totes les sentències. S’utilitza normalment per sortir d’una iteració sense deixar que acabi d’executar totes les sentències. Exemple: algorisme Amitges és var comptador: enter; fvar per comptador en [1..10] fer escriuEnter(comptador); si (a=5) trencar; fper falgorisme Aquest algorisme escriu els nombres de l’1 al 5. Continuar. Continuar s’utilitza per avaluar l’expressió de continuació d’una iteració abans del moment que li pertoca comprovar-la. S’utilitza normalment quan es detecta que certes sentències poden fer arribar al final de la iteració abans d’hora, i per tant al resultat esperat, sense haver-ne de comprovar la resta. Exemple: algorisme Abans és var edat, sumaEdats: enter; fvar sumaEdats:=0; mentre edat < 300 i edat ≠ 100 fer llegirEnter(edat); si (edat = 100) continuar; sumaEdats:= sumaEdats + edat; fper falgorisme




Aquest algorisme s’acaba si la suma d’edats es igual o superior a 300, o bé si algú té 100 anys. Fixeu-vos que si algú té 100 anys l’algorisme no espera a fer la suma d’edats, sinó que comprova immediatament la condició de continuació. Retorna(estat). Aquesta funció retorna el control al sistema o a qualsevol altre procés anterior. La funció permet retornar un valor indicant si l’acabament ha estat o no correcte o en general el seu estat final. De moment aquest tipus de salt no l’utilitzarem en algorísmica. Més endavant quan farem el tema de funcions i accions l’utilitzarem. Saltar etiqueta. Es tracta d’un salt incondicional a una etiqueta prèviament definida al codi. Aquest tipus de salt no l’utilitzarem mai en programació estructurada.

2.10 Tipus de dades Enumerades. Una enumeració és un procés pel qual s’estableix una correspondència, d’un a molts, entre una variable entera i els únics valors que aquesta pot prendre. Els valors de la variable, que es defineixen com a possibles dins l’enumeració, estan associats a identificadors que, si no s’inicialitzen, prenen valors correlatius. Enumeracions en algorísmica. La sintaxi que farem servir és: enum <nom> = (<identificador> [,<identificador>...] ) ; En algorísmica suposarem que els identificadors no s’inicialitzen. Els elements de l’enumeració tenen un ordre que és precisament l’ordre en què s’han escrit els valors. En llenguatge C no és exactament així. Exemple: enum dies = (dilluns, dimarts, dimecres, dijous, divendres, dissabte, diumenge) ;

Amb aquesta declaració acabem de definir un nou tipus de dada simple que podem fer servir en el nostre programa. Una vegada tenim declarada l’enumeració, podrem definir variables d’aquest tipus i operar-hi juntament amb els operadors que veurem a continuació.




Així, doncs, podem declarar: var dia: dies; fvar I podem fer assignacions del tipus: dia= dilluns; Abans de declarar una variable de tipus enumeració, aquesta ha d’haver estat definida. El concepte d’enumeració ha estat el primer que ens ha permès declarar tipus nous en els nostres programes. Aquesta pràctica és fonamental per poder dissenyar algorismes entenedors i eficients. En algorísmica és obligatori declarar els tipus en una zona especial per a aquesta finalitat (de manera semblant a la declaració de constants i de variables). Recordem, en color vermell, on es troba aquesta zona dins l’estructura d’un programa:

Estructura genèrica d’un Algorisme.

algorisme momAlgorisme és

const

[definició de constants]

fconst

tipus

[definició de tipus]

ftipus

var

[declaració de variables]

fvar

{acció 1}

{acció 2}

...

falgorisme




Així en l’exemple anterior, hauríem escrit: tipus enum dies = (dilluns, dimarts, dimecres, dijous, divendres, dissabte, diumenge) ;

ftipus var dia: dies; fvar Operadors sobre els tipus de dades enumerats. En realitat les operacions són funcions, això implica que retornen un resultat. Atesa una variable x corresponent a un tipus de dada enumerat, tenim les operacions (funcions) següents: suc(x), que retorna el valor de la dada enumerada immediatament superior a x; si x és la més gran, retorna la mateixa x; pre(x), que retorna el valor de la dada enumerada immediatament inferior a x; si x és la més petita, retorna la mateixa x; ord(x), que retorna un nombre natural corresponent al número d’ordre de x dins l’enumeració (suposarem que comencen a comptar des de zero). Aquests tipus de dades permeten fer servir els operadors relacionals.

2.11 Subtipus de dades en algorísmica. Alguns llenguatges incorporen la possibilitat de delimitar el conjunt de valors possibles per als tipus enter, natural i caràcter (tipus estàndards) i per als tipus enumerat (definit pel programador), definint un nou tipus que és considerat subtipus del tipus del qual els seus valors en són subconjunt. Les operacions permeses en els subtipus són les mateixes que les delstipus dels quals deriven. En llenguatge C no hi ha la possibilitat de declarar subtipus; en canvi, ja sabem que el tipus enum del llenguatge C és molt més potent que el tipus enumerat vist en algorísmica. Per tant, només farem referència a subtipus en algorísmica. La sintaxi és la següent:

tipus <nom_tipus> = <llista_valors_possibles> | <interval_valors_possibles>; ... ftipus




Exemples de definició de subtipus:

tipus sexe = 'H', 'D'; trimestres = 1,2,3,4; /* o també 1..4 */ notes = 0..10; enum dies = (dilluns, dimarts, dimecres, dijous, divendres, dissabte, diumenge); diesfeiners = dilluns...divendres; diesfestius = dissabte...diumenge;

ftipus

2.12 Tipus de dades compostes (cadenes, taules i tuples). Introducció. Fins ara les dades amb que treballàvem podien ser d’un dels quatre tipus elementals: enter, real, caracter i booleà. Hi ha problemes, però, que requereixen treballar amb tipus de dades més complicats, com ara llistes de notes, números complexos, vectors, matrius, etc. Fer que el nostre llenguatge algorísmic proporcionés més tipus de dades (per exemple, un tipus pels nombres complexos, un altre pels racionals, un altre pels punts del pla, un altre pels punts de l’espai, etc) seria massa complicat, i encara així només recolliria un conjunt finit de tipus de dades diferents. En comptes d’això, el llenguatge algorísmic proporciona només quatre tipus elementals, peró a més a més proporciona dos mecanismes per definir nous tipus de dades combinant altres tipus ja definits, de forma que per cada problema podem definir els tipus de dades que més ens convinguin. Per tant, tenim dues classes de tipus de dades:

Tipus elementals Són els tipus que hem vist fins ara: enter, real, caràcter i booleà. Són les peces elementals a partir de les quals es defineixen tipus més complexes, com textos (llista de caràcters), números complexos (un parell de reals), etc.

Tipus estructurats (també anomenats compostos o definits per l’usuari) Són els tipus que defineix l’usuari a partir d’altres tipus més senzills, en funció dels requeriments del seu problema. S’anomenen tipus compostos perquè permeten emmagatzemar múltiples valors, ja siguin tots del mateix tipus (donant lloc a les taules) o de diferent tipus (donant lloc a les tuples).




Anomenem constructor de tipus al mecanisme del llenguatge algorísmic que ens permet definir taules i tuples a partir de tipus elementals i de taules i tuples definides prèviament. El treball amb taules i tuples afecta a tres parts d’un algorisme:

algorisme NomdelAlgorisme és

const {Definició de constants}

fconst

tipus {Definició de tipus: es defineix el format o estructura del tipus}

ftipus

var {Declaració de variables: es declaren les variables del tipus}

fvar

Accio1 {es fan servir les variables} Accio2 Accio3 ...

Falgorisme Exemple de taula Per les notes d'un grup de 10 alumnes, farem servir una taula de 10 elements numerats de l'1 al 10: algorisme exemple és

tipus Notes = taula [1..10] de real

ftipus {a partir d'aquest punt podem declarar variables de tipus Notes}

var grup1, grup2, grup3: Notes

fvar {ara podem fer operacions amb les variables grup1... de tipus Notes} grup1[1]:= 8.0

falgorisme




Exemple de tupla. Pels pacients d'un hospital, farem servir una tupla (o registre) amb tres camps:

algorisme exemple és tipus

Pacient = tupla dni: enter NIF: caracter pes: real

ftupla ftipus {a partir d'aquí podem declarar variables del tipus Pacient} var

p1, p2, p3: Pacient fvar p1.dni:=46635812 p1.NIF:=’S’

falgorisme




2.12.1 Taules Introducció. Les taules permeten definir objectes formats per un conjunt de valors tots del mateix tipus. Una taula està formada per un conjunt de cel·les. L’accés a cadascún dels elements d’una taula es realitza mitjançant un enter que s’anomena índex. Algorisme exemple és tipus Abecedari = taula [1..28] de caracter ftipus

Definim un nom tipus anomenat Abecedari

com una taula de 28 caràcters, numerats de

l’1 al 28. Ara ja podem definir variables de

tipus Abecedari

var abc_majuscules, abc_minuscules: Abecedari

fvar

Declarem dos variables de tipus Abecedari. Cadascuna d’aquestes variables és una taula

de 1a 28 de caràcters.

abc_majuscules[1]:='A' abc_majuscules[28]:='Z'

La forma d’accedir a una cel·la de la taula és mitjançant un índex en el rang 1..28

(indexació). falgorisme

Definició de taules. La definició d’una taula es posa en l’apartat de definició de tipus:

algorisme NomdeAlgorisme és


fconst

tipus {Definició de tipus}

ftipus

var

{Declaració de variables} fvar {Accions} ...

falgorisme




La sintaxi de la definició d’una taula té aquest format:

El nom del nou tipus l’escriurem amb la lletra inicial en majúscula (Abecedari)

El rang [1..28] determina el número d’elements que tindrà la taula (28), així com la seva numeració (el primer té índex 1, el segon 2, etc.). Els índexs només poden ser enters.

El tipus base és el tipus de cadascun dels elements de la taula (pot ser un tipus elemental o un tipus definit prèviament).

Observeu que la definició d’un tipus determina bàsicament el seu format o la seva estructura. La definició d’un tipus ens permet declarar variables d’aquell tipus, totes les quals compartiran la mateixa estructura:

A la dreta es mostra la estructura del tipus

Abecedari: una taula amb 28 cel·les, on cada

cel·la podrà emmagatzemar un caracter.

1 caracter

2 caracter

3 caracter

4 caracter

...

...

...

...

28 caracter Abecedari




Declaració de variables de tipus taula Un cop definim un nou tipus, podem declarar variables d'aquest tipus, en l’apartat de declaració de variables:



fconst tipus

{Definició de tipus} ftipus

var {Declaració de variables}

fvar

{Accions} ...

falgorisme

Aquí teniu un exemple:

var a: enter abc_majuscules, abc_minuscules: Abecedari

fvar

Internament, cada variable de tipus Abecedari (abc_majuscules i abc_minuscules) té assignat un espai a la memòria del computador on hi ha prou espai per emmagatzemar 28 caràcters.

1 ‘A’

2 ‘B’

3 ‘C’

4 ‘D’

...

... ... ...

28 ‘Z’

abc_majuscules

La quantitat de memòria necessària per emmagatzemar una taula és proporcional al número d'elements determinat pel rang. Això vol dir que una taula definida com [1..1000000000] de real segurament provocarà un error.




Operacions amb taules Un cop hem declarat variables de tipus taula, podem treballar amb aquestes variables:



fconst tipus

{Definició de tipus} ftipus var

{Declaració de variables} fvar

{Accions} ...

falgorisme

Recordeu que el tipus de dades no només determina la representació interna de les variables, sino també elconjunt d’operacions que podem fer sobre aquestes variables. Cap de les operacions que hem vist pels objectes de tipus enter, real, etc. (*, /, +, -, etc.) es pot aplicardirectament a una taula. Les úniques operacions vàlides per una taula són l’assignació i la indexació.

Assignació entre taules El nostre llenguatge algorísmic permet fer l’assignació entre dues taules, sempre i quan siguin del mateix tipus.

Exemple: var

abc1, abc2: Abecedari fvar abc1 := abc2

L’assignació anterior fa que es copiïn tots els elements de abc2 sobre abc1, de forma que després d’executar-se l’assignació, les cel·les de la taula abc1 contenen exactament els mateixos valors que les cel·les de la taula abc2 (òbviament, abc2 ha d’haver-se inicialitzat prèviament).




Comentari: Malauradament, el llenguatge C no suporta directament l’assignació entre variables de tipus taula, per la qual cosa, quan traduïm una assignació entre taules a C, cal fer una còpia element a element (amb una estructura per).

Indexació de taules Per accedir als diferents elements d’una taula es fa servir un enter que s’anomena índex. Aquest accés s’anomena indexació. El format és molt senzill; es posa el nom de la variable que hem definit com una taula, seguit de l’índex entre claudators:

variableTaula[index]

Exemples: b[1] fa referència al primer element de la taula Abecedari (perquè està definida de 1 a 28), b[2] fa referència al segon, i així successivament fins b[28] que és el darrer element.

En general podem fer servir qualsevol expressió entera com a índex, no cal que sigui un valor:

b[1+1]

b[2*i+4]

Ara bé, l’índex ha de ser sempre un enter, i ha d'estar sempre dins el rang de la taula; en cas contrari, es considera un error. Cada element d'una taula té exactament les mateixes propietats que el tipus base: b[2] és un caracter perquè Abecedari és una taula de caràcters. Per tant, b[2] pot aparèixer en qualsevol context en que pugui aparèixer una variable de tipus caracter, com ara:

EscriureCaracter(b[2])

si b[2]<b[3] llavors ...

Distinció entre tipus i variables Important: Observeu que hi ha una clara distinció entre el tipus (enter, Abecedari) i les variables d’aquell tipus (a, b,c,...). No té cap sentit fer servir el nom del tipus com si fos una variable:

Incorrecte Correcte enter := 5 Abecedari[1] := ‘A’

a := 5 b[1] := ‘A’




Exemples Matrícula d’un cotxe, núm. binari, punt del pla, punt de l'espai 3D, polinomi de grau 4, etc.

Matrius. Una matriu no és res més que una taula amb més d'una dimensió: En aquest cas, TaulerEscacs és una taula amb dues dimensions. El primer rang s'aplica al primer índex i el segon rang al segon índex. Per tant, els elements d'aquesta taula s'indexen així:

var t: TaulerEscacs

fvar t[2][1]:='P' t[2][2]:='P' t[2][3]:='P' ...

Un altre exemple:

tipus ImatgeBN = taula [1..640][1..480] de boolea Port = taula [1..100][1..100][1..3] de enter

ftipus var

i: ImatgeBN p: Port

fvar i[1][1]:=cert p[1][1][2]:=34424

Exemples d’operacions típiques amb taules




2.12.2 Tuples Introducció. Les tuples (també anomenades registres) permeten definir objectes formats per un conjunt de valors cadascú dels quals té el seu propi tipus. Els elements d’una tupla s’anomenen camps. L’accés a cadascun d’aquests elements es realitza mitjançant el nom del camp. Una tupla es pot veure com una agrupació de variables relacionades. Per exemple, si per cada pacient d’un hospital ens interessa emmagatzemar el seu dni, el número d’habitació i si és o no perillós, en lloc de declarar variables separades per cadascuna d’aquestes dades, definim un nou tipus Pacient amb tres camps: dni, habitació i esPerillos. En el següent exemple es treballa amb 3 pacients i es mostra la diferència entre no fer servir tuples i fer-les servir: Exemple sense tuples (la vinculació entre les variables no queda prou clara)

Exemple amb tuples (més entenedor i amb menys variables)

algorisme

algorisme tipus Pacient = tupla dni, habitacio: enter esPerillos: boolea ftupla ftipus

var dni1, dni2, dni3, h1, h2, h3: enter perill1, perill2, perill3: boolea fvar dni1:=46728643 h1:=221 perill1:=fals h2:=324 falgorisme

var p1, p2, p3: Pacient fvar p1.dni:=46728643 p1.habitacio:=221 p1.esPerillos:=fals p2.habitacio:=324 falgorisme




Definició de tuples. La definició d’una tupla es posa en l’apartat de definició de tipus:

algorisme NomAlgorisme és


fconst

tipus {Definició de tipus} ftipus

var

{Declaració de variables} fvar {Accions} ...

falgorisme La sintaxi de la definició d’una tupla té aquest format:

El nom de la tupla porta la lletra inicial en majúscules: Alumne.

El tipus de cada camp pot ser un tipus predefinit (enter, real, caracter, boolea) o un tipus definit prèviament (Pacient, Punt2D, etc.), ja sigui una taula o una altra tupla.




Observeu que la definició d’un tipus determina bàsicament el seu format o la seva estructura. La definició d’un tipus ens permet declarar variables d’aquell tipus, totes les quals compartiran la mateixa estructura:

Declaració de variables de tipus tupla. Un cop definim un nou tipus, podem declarar variables d'aquest tipus, en l’apartat de declaració de variables:



fconst tipus {Definició de tipus} ftipus

var {Declaració de variables} fvar

{Accions} ...

falgorisme Aquí teniu un exemple:

var

a: enter

p1, p2, p3: Pacient

a1, a2: Alumne

fvar




Operacions amb tuples. Un cop hem declarat variables de tipus taula, podem treballar amb aquestes variables:



fconst tipus {Definició de tipus} ftipus var {Declaració de variables} fvar

{Accions} ...

falgorisme

Recordeu que el tipus de dades no només determina la representació interna de les variables, sinó també el conjunt d’operacions que podem fer sobre aquestes variables. Cap de les operacions que hem vist pels objectes de tipus enter, real, etc. (*, /, +, -, etc.) es pot aplicar directament a una tupla. Les úniques operacions vàlides per una taula són l’assignació i l’accés a un camp. Assignació entre tuples. El nostre llenguatge algorísmic permet fer l’assignació entre dues tuples, sempre i quan siguin del mateix tipus. Exemple:

var

p1, p2: Alumne

fvar

p1 := p2




L’assignació anterior fa que es copiïn tots els camps de p2 sobre p1, de forma que després d’executar-se l’assignació, els camps de la tupla p1 contenen exactament els mateixos valors que els camps de la tupla p2 (òbviament, p2 ha d’haver-se inicialitzat prèviament). Comentari: Afortunadament, el llenguatge C sí suporta directament l’assignació entre variables de tipus tupla, cosa que no passava amb les taules. Accés a un camp. Per accedir als diferents camps d’una tupla es fa servir el nom del camp que es va donar en la definició de la tupla. El format és molt senzill; es posa el nom de la variable que hem definit com una tupla, seguit d’un punt i del nom del camp:

variableTupla.nomcamp Exemple:

b.dni fa referència al primer camp de la tupla Pacient, que és de tipus enter.

Cada camp d'una tupla té exactament les mateixes propietats que el tipus amb el qual s'ha definit: b.dni és un enter, b.esPerillos és un booleà, etc. i poden aparèixer en qualsevol context en que pugui aparèixer un enter/booleà respectivament, com ara:

b.dni:=LlegirEnter()

si b.es_perillos llavors... Distinció entre tipus i variables. Recordeu que, com passava amb les taules, no te sentit fer servir el nom del tipus com si fos una variable:

Correcte:

a:=5

b.dni:=46781111

a2.treballa:=cert

Incorrecte:

enter:=5

Pacient.dni:=46781111

Alumne.treballa:=cert

Exemples. Matrícula vehicle, punt del pla, punt de l'espai 3D, núm. complex, data cronològica...




Combinacions de taules i tuples Taules i tuples es poden combinar sense restriccions:

Taules de taules

Taules de tuples

Tuples amb taules

Tuples amb tuples

2.13 Tractament de cadenes. Les cadenes es defineixen com una taula de tipus caràcter d’una sola dimensió:

tipus Paraula = taula [1..25] de caracter

ftipus paraula és un nou tipus que pot contenir una cadena de 25 caràcters. Ara podem definir variables de tipus paraula:

var

p1, p2: Paraula

fvar

Podem accedir, de forma individual, als caràcters que formen el tipus paraula. Exemple: p1[1] representa el primer caràcter de la cadena p1. ... p[25] representa el darrer caràcter de la cadena p1. Accés de lectura: escriureCaracter( p1[1] ); Accés d’escriptura: p[1]= ‘a’




2.14 Gestió de taules: tractament seqüencial, ordenació, cerca

dicotòmica, inserció ordenada. La gestió de taules permeten emmagatzemar moltes dades consecutives a memòria, del mateix tipus, sota el mateix identificador i un índex, enter, que permet referenciar-les. Sovint ens pot interessar fer una operació amb totes, o una part, de les dades d’una taula (tractament seqüencial), ordenar-les, fer-hi una cerca, inserir a la taula les dades de forma ordenada, o qualsevol altre tipus de tractament sobre la taula. Tot seguit veurem algun d’aquests tractaments sobre taules.

2.14.1. Tractament seqüencial.

El tractament seqüencial permet accedir consecutivament als elements d’una taula per tal de fer-ne algun tractament. Si ens interessa tractar totes les dades d’una taula de forma seqüencial, podem utilitzar la iteració per. Recordem que si volem recórrer tota la taula sabem quants cops hem d’iterar, exactament la seva dimensió màxima. Exemple: Pujar un 20% el sou dels 25 treballadors de l’empresa.

algorisme AugmentDeSou és tipus Sou = taula [1..25] de enter ftipus var s1: Sou a: enter fvar //10 treballadors que cobren 1500 euros per a en [1..10] fer s1[a] = 1500 fper //15 treballadors que cobren 1000 euros per a en [11..25] fer s1[a] = 1000 fper //pujar el sou de tots els treballadors un 20% per a en [1..25] fer s1[a] = s1[a] + s1[a] * 0,2 fper

falgorisme




Si volem fer el tractament seqüencial de tots els elements d’una taula de dues dimensions hem de niar dues iteracions. Exemple: Recórrer un taulell d’escacs posant-hi un * en cada una de les cel·les. ... tipus Taulell = taula [1..8][1..8] de caracter ftipus var

t1: Taulell

fil,col: enter fvar

per fil en [1..8] fer

per col en [1..8] fer t1[fil][col] := ‘*’ fper fper ... En general per recórrer una taula d’n dimensions, hem de niar n iteracions de tipus per, on cada iteració ha d’iterar tants cops com l’índex màxim de cada una de les dimensions respectivament.

2.14.2. Ordenació.

De vegades ens pot interessar tenir els elements d’una taula ordenats. D’aquesta manera per exemple, trobar un element, no necessàriament significarà recórrer tots els elements de la taula. En molts casos, si la taula està ordenada, podrem millorar el cost de cercar d’un element dins d’aquesta. Existeixen molts algorismes d’ordenació. Nosaltres ens limitarem a veure un dels mètodes d’ordenació més senzills que existeixen anomenat Bubble sort (ordenació de bombolla). Val a dir, que aquest mètode té un cost d’execució força dolent (O(n2)). Tot i així, per la seva senzillesa es fa especialment adient en aquest moment de l’assignatura. Funciona revisant cada element de la llista a ordenar amb el següent, intercanviant-los de posició si estan en l'ordre equivocat. Cal revisar diverses vegades tota la llista fins que no es necessitin més intercanvis, la qual cosa significa que la llista està ordenada. Aquest algorisme obté el seu nom de la forma amb la que pugen per la llista els elements durant els intercanvis, com si fossin petites "bombolles". També és conegut com el mètode d'intercanvi directe. Se'l considera un algorisme de comparació, atès que només fa servir comparacions per ordenar els elements, sent el més senzill d'implementar.

http://ca.wikipedia.org/wiki/Algorisme




Codi de l’algorisme: ... // algorisme d’ordenació pel mètode de la Bombolla const MAX : enter = 10 fconst tipus LlistaEnters = taula [1..MAX] de enter ftipus var

// a és un vector de MAX elements de tipus enter a : LlistaEnters aux , i , j : enter fvar

per i en [1..MAX-1] fer

per j en [1..MAX-i] fer si ( a[j]>a[ j+1 ] ) llavors aux := a[ j ] a[ j ] := a[ j+1 ] a[ j+1 ] := aux fsi fper fper ... Aquest algorisme realitza l'ordenació d'una llista a d’n valors, en aquest cas d’n termes numerats d’1 a MAX, consta de dos bucles niats un amb l'índex i , que dóna una grandària menor al recorregut de la bombolla en sentit invers d’1 a MAX-1 , i un segon bucle amb l'índex j , amb un recorregut d’1 fins a MAX-i , per a cada iteració del primer bucle, que indica el lloc de la bombolla. La bombolla són dos termes de la llista seguits, j i j+1 , que es comparen, i si el primer és menor que el segon els seus valors s'intercanvien. Aquesta comparació es repeteix al centre dels dos bucles, donant lloc a una llista ordenada. Es pot veure que el nombre d’iteracions depèn exclusivament del nombre d’elements MAX, i no de si estan o no ordenats els termes, és a dir, si inicialment ja tenim una llista ordenada, realitzarà totes les comparacions exactament igual que si la llista no està ordenada. Aquesta és una característica d'aquest algorisme.




2.14.3. Cerca dicotòmica.

L’algorisme de cerca dicotòmica s’inspira en una idea ben senzilla que de ben segur haureu aplicat en alguna ocasió. Suposeu que heu de cercar el telèfon d’un amic a la guia telefònica. Veritat que no comenceu per la primera pàgina? Sovint agafem una pàgina qualsevol de la guia, a l’atzar, i comparem la primera lletra del cognom del nostre amic amb la primera lletra del nom que apareix a la plana que hem escollit a l’atzar. A partir d’aquí, determinem en quina part de la guia, anterior o posterior al punt on ens trobem, es pot trobar el nom que cerquem i continuem amb el mateix procediment fins a arribar a la plana on hi ha el nom que cerquem. És més, podem afirmar si el nom és a la guia o no sense necessitat de llegir tots els noms de la guia gràcies al fet que a la guia els noms estan disposats segons un ordre alfabètic. Aquí resumirem aquesta idea aplicada a una taula, i això ens donarà les bases per a escriure’n l’algorisme corresponent .

1. Agafem l’element del mig de la taula i el comparem amb l’element cercat: a. Si l’element del mig és més petit que l’element que es busca, descartem

la primera meitat de la taula (ja que només podrà contenir valors menors que el cercat).

b. Si, en canvi, l’element del mig és més gran (o igual) que el buscat, descartem la segona meitat de la taula.

2. Apliquem el mateix esquema a la meitat de la taula no descartada com si es tractés d’una taula sencera.

Repetim aquests passos fins que ens quedarem amb una part no descartada de la taula d’un sol element. L’algorisme següent aplica aquesta idea (per N més gran que 0):

Algorisme CercaDicotomica és const

N: enter = 10 // per N > 0

fconst var t: taula[N] de enter; donat: enter; inici, fi, mig: enter fvar omplirTaula(t); donat:= llegirEnter(); inici:= 1; fi:=N; mentre inici ≠ fi fer mig:= (inici+fi) div 2; si t[mig] < donat llavors inici:= mig + 1; sino fi:= mig; // recordeu que la guarda és ≥

fsi fmentre si t[inici] = donat llavors escriureParaula(‘Trobat’); sino escriureParaula(‘No trobat’); fsi falgorisme




Fixeu-vos que quan actualitzem els límits de la taula no descartada, si no es compleix la condició t[mig] < donat (i, per tant, es complirà t[mig] ≥ donat), hem de fer fi := mig i no fi := mig-1, o només consideraríem la possibilitat f[mig] ≥ donat i exclouríem el possible cas t[mig] = donat. LA cerca dicotòmica és força eficient. A cada iteració descartem la meitat dels elements que queden. Hem de tenir present, però, que només podem aplicar aquesta tècnica si sabem que el vector està ordenat.

2.14.4. Inserció ordenada.

El mètode de la inserció ordenada consisteix a aconseguir que una taula s’empleni de manera ordenada, és a dir, que en cap moment deixi d’estar ordenada. És clar que la primera inserció que es produeixi a la taula correspondrà situar-la a la primera posició i la taula restarà ordenada perquè encara no hi ha cap element. A partir d’aquest moment, ja sempre cal esbrinar la posició en què cal situar un nou element. Hi ha, bàsicament, dues possibilitats: Que pertoqui situar-lo a la posició posterior a la darrera ocupada.

1. Que pertoqui situar-lo en una posició ja ocupada, la qual cosa implicarà desplaçar tots els elements situats a partir d’aquella posició una casella més endavant (cap a la fi de la taula).

Aquestes possibilitats s’han de complementar, evidentment, amb les preguntes següents:

Queda espai a la taula per afegir-hi nous elements?

Hi pot haver elements repetits segons el criteri d’ordenació? I segons altres criteris?

En el cas que es permetin elements repetits, on se situen: abans o després dels que ja existien?




Inserció ordenada: algorisme en pseudocodi.

Vegeu l’algorisme per inserir un element en una taula d’enters de manera que sempre es mantingui ordenada ascendentment. Algorisme inserció_ordenada és : enter

const MAX: enter = 10

fconst

/* Descripció:

t : Taula d’enters ordenada ascendentment on s'ha d'inserir ordenadament un element. Capacitat MAX. e : Element que es vol inserir nt : Quantitat real d'elements existents a la taula Retorna: 0 : Si s'ha pogut realitzar la inserció. En tal cas, t i nt hauran estat modificats 1 : No s'ha pogut realitzar la inserció per manca d'espai */

var t[MAX]: enter; i,j,ele,nt: enter;

fvar t[]={2,5,17,22,56,45}; nt=6; //inicialitza variables per provar el programa si (nt == MAX) llavors retorna 1; fsi i = 0; /* La taula està ordenada ascendentment. No es demana controlar que no hi

pugui haver elements repetits respecte de l'apartat que manté l'ordre. Per tant, si a la taula ja hi ha un element que en l'apartat t conté el mateix valor que conté l'element que hi volem afegir, no hi ha d'haver problema. Normalment l'element que s'insereix s'afegeix al final de tots els elements amb valor igual en el camp t que l'element que es vol inserir.

*/ mentre ( i < nt i t[i] ≤ e ) fer i = i + 1; fimentre /* Quan surt del mentre, la variable i conté la posició en què ha de situar-se l'element e. Pot donar-se el cas que s'hagi de situar a la posició n, cosa que succeeix si el valor e és superior al valor dels camps t[i] per totes les posicions plenes de la taula (des de 0 fins a nt-1). Sigui quin sigui el valor de i, cal moure els elements de les posicions i a nt-1 una posició cap avall, la qual cosa s'ha de fer començant per l'element de la posició nt-1 i, seguint cap amunt, fins a l'element de la posició i. */




j = nt-1;

mentre ( j ≥ i ) fer

t[j+1] = t[j] ; j = j-1;

fimentre /* En aquest moment ja s'ha deixat l'espai de la posició i lliure per posar-hi l'element e */ t[i] = e; nt = nt+1; retorna 0; falgorisme En acabar l’algorisme, l’element e, ha estat inserit al vector d’enters t de forma ordenada.

2.15 Depuració d’errors. (fet a classe)

2.16 Documentació dels programes. Fet al document de teoria del tema 1. Tot i així, el tema de la documentació es veurà més a fons a la UF2.

2.17 Entorns de desenvolupament de programes. (fet a la UF1)

2.18. Esquemes algorísmics. Un esquema algorísmic és una solució genèrica de codi que mostra com resoldre un determinat tipus de problemes. Nosaltres en veurem un parell: L’esquema de recorregut per una seqüència i l’esquema de cerca d’un element dins d’una seqüència La idea bàsica és aprofitar el fet que molts problemes, aparentment diferents, en realitat fan essencialment el mateix, i per tant es poden resoldre de forma genèrica.




2.18.1. Esquema de recorregut d’una seqüència. Aquest esquema ens mostra una solució per recórrer tots els elements d’una seqüència en la qual podem tractar, si ens convé, cada un dels seus elements. Incialitzacions; mentre( no_final ) fer Tractar; Obtenir_següent; fmentre [tractar_darrer] Hi ha molts problemes la solució dels quals passa per fer un cert tractament a una sèrie d'elements: trobar el màxim d'una taula, trobar-ne la mitjana, comptar la longitud d'una palabra, etc. Exemple: Augmentar un 10% el sou a tots els treballadors de l’empresa. Pre: {souTreballadors és un vector de tipus float amb els sous dels treballadors i MAX és el nombre de treballadors i alhora la dimensió del vector} //inicialitzacions

i=1; mentre( i≠MAX ) fer //tractar

souTreballadors[i] = souTreballadors[i] + souTreballadors[i]*0,10; //obternir_següent

i++; fmentre

final seria i=MAX , per tant, no final serà i ≠ MAX

Tractar darrer, no sempre cal implementar-ho, només s’implementa quan sigui necessari.

Cal recordar que en algorísmica el primer element d’un vector és l’1.




2.18.2. Esquema de cerca en una seqüència. Aquest esquema s'aplica quan, per obtenir el resultat, només volem obtenir el primer element d’una seqüència que verifica una determinada propietat. Per tant, si el trobem aviat, no cal que continuem tractant la resta de la seqüència. var trobat: boolea fvar trobat:=fals obtenir_primer; mentre (no_final i no_trobat) fer si(trobat) llavors trobat:=cert; fsi obtenir_següent; fmentre [tractar_darrer]

Documents

M3 - UF1 - T2