¡Descarga Algoritmos y programas: Introducción a la programación informática y más Apuntes en PDF de Introducción a la Informática solo en Docsity!
Fonaments d'informàtica
2. Algoritmes i programes
Índex del tema Objectius.................................................................................................................................. 1 2.1. Definicions d'algoritme i programa................................................................................... 1 2.2. Pseudocodi....................................................................................................................... 2 2.3. Organigrama..................................................................................................................... 4 2.3.1. Símbols dels organigrames....................................................................................... 5 2.3.2. Exemples d'organigrames......................................................................................... 8 Exercicis proposats................................................................................................................ 11
Objectius
- Saber què és un programa i un algoritme.
- Conèixer dos formes d'escriure algoritmes.
- Conèixer i saber utilitzar els símbols per escriure organigrames.
- Saber quan utilitzar pseudocodi o organigrama.
2.1. Definicions d'algoritme i programa
Al capítol anterior hem introduït el concepte de programa i hem vist com funcionava un ordinador per aconseguir executar programes. Ara, veurem, més en profunditat, el que s'amaga darrera del terme programa. Fent una definició més exacta diríem que un Programa és la traducció d'un algoritme a un llenguatge de programació que, un cop traduït, al seu torn, a llenguatge màquina, pot ser executat per la CPU d'un ordinador. Però, què és un algoritme? Anomenem algoritme a una seqüència finita d'instruccions a seguir per a resolució d'un problema. Dit amb altres paraules, algoritme és el com es resol un problema. Fixem-nos en la definició que parla de seqüència finita d'instruccions. És lògic pensar que si, per resoldre un problema, haguéssim de seguir un nombre infinit de passos, el problema no s'acabaria de resoldre mai o, el que és el mateix, no tindria solució. També hem de destacar que parlem de seqüència , i això implica un ordre. És important, per tant, l' ordre de les instruccions. Un canvi en l'ordre pot implicar no arribar a la solució correcta Aquesta definició de programa també ens fa constatar que hem de pensar primer com resoldre el problema (l'algoritme) i, desprès, ja farem servir un llenguatge de programació per escriure l'algoritme en un idioma que l'ordinador pugui entendre, ja sigui directament (llenguatge màquina) o mitjançant un traductor (llenguatge d'alt nivell). Un programador experimentat podrà escriure un problema senzill directament en el llenguatge que vulgui. Però, els problemes complexos necessitaran, primer, d'un anàlisi exhaustiu per a saber com resoldre'l, i desprès ja es farà la traducció.
Algoritmes i programes Els algoritmes els utilitzem contínuament a la nostra vida quotidiana. Molts ens els han ensenyat al col·legi, altres els hem après amb la pràctica diària. Alguns són propis de cadascú. Però, una cosa està clara, tots en fem ús d'un munt d'ells de forma automàtica o inconscient. Posem alguns exemples:
- Per sumar dos números ens van ensenyar un procediment (un algoritme) que apliquem sense adonar-nos.
- Per calcular una arrel quadrada fem servir un altra algoritme però, habitualment, sí som conscients de que estem seguint un procediment, ja que no el tenim tan assimilat.
- Per cuinar el plat que ens agrada seguim un procediment que hem vist fer moltes vegades o bé que llegim d'un llibre de receptes.
- Per a conduir, per trucar per telèfon, per a programar el vídeo, etc. Però agafem un d'aquest exemples. La recepta de cuina. Està clar que és un algoritme, és una seqüència finita d'ordres que seguides per una CPU (nosaltres) ens resolen un problema (aconseguir un plat cuinat que es pugui menjar). Fixem-nos que les receptes de cuina estan escrites en un llenguatge que nosaltres (la CPU) entenem. El problema radica en que el nostre llenguatge és, sovint, ambigu. Aquesta ambigüitat implica que dos persones poden interpretar la mateixa ordre de formes diferents. Moltes vegades, les quantitats d'un ingredient són poc rigoroses, fent que el cuiner tingui que posar la seva pròpia iniciativa. Això, condueix com a resultat que el mateix plat sigui diferent depenent de la interpretació del cuiner. Aquest fet és, en el cas de la cuina, desitjable i fa que la cuina no sigui aburrida, però és evident que el cas de la programació d'ordinadors no és gens desitjable. ¿Algú es pot imaginar que passaria si, cada cop que vulguem que el nostre programa de comptabilitat faci el balanç d'explotació, ens donés resultats diferents (encara que siguin lleugerament diferents) amb les mateixes dades de partida? Per tant, per escriure algoritmes informàtics, necessitem eines que facin que l'algoritme resultant no sigui ambigu i només es pugui interpretar d'una única manera. Bàsicament disposem de dos eines: una eina gràfica, anomenada organigrama i un llenguatge de programació que no sigui tan rigorós ni tan rígid com el dels llenguatges de programació que poden ser compilats, i que anomenem pseudocodi.
2.2. Pseudocodi
Com ja hem dit pseudocodi és un llenguatge de programació sense la rigidesa pròpia dels llenguatges de programació reals. Habitualment, a més a més, les instruccions les escriurem amb paraules del nostre idioma natural i no en anglès. Els llenguatges de programació reals tenen compiladors que tradueixen el programa a codi màquina. Per aconseguir això necessiten ser concisos, amb una sintaxis molt rígida i estricte. Sovint, aquestes normes estrictes, fan que estem més pendents de com escriure correctament que del què volem dir. Fent servir un llenguatge més proper i menys estricte, ens podem concentrar millor en el com resoldre el problema i, un cop resolt, escriure el mateix amb el llenguatge de programació. També ens permet escriure algoritmes que desprès pugin ser traduïts al llenguatge de programació que es vulgui. Si l'escrivísim, per exemple, en C i el volguéssim en Pascal el programador hauria de saber C i Pascal. El fet que sigui poc estricte ens permet, quan ens interessi, ser molt genèric i no distreure'ns en coses que siguin evidents a l'hora de traduir-ho al llenguatge de programació real. Com s'assembla molt a un llenguatge de programació l'anirem introduint al llarg de tot el llibre al mateix temps que anem introduint el llenguatge Pascal.
Algoritmes i programes Com es pot observar hem fet servir un pseudocodi molt precís. Per tant, no hi ha gaire diferència amb qualsevol altre llenguatge de programació. Però a l'exemple 2 l'hem fet menys estricte, eliminant les instruccions que són superflues per a la resolució del problema i que, en els programes, serveixen d'ajuda pels usuaris del programa. Segurament perdem precisió, però guanyem en llegibilitat de l'algoritme.
2.3. Organigrama
L'organigrama o diagrama de flux és una representació gràfica d'un algoritme, on queda de manifest, fonamentalment, el flux d'execució de les ordres. Aquesta representació gràfica la farem utilitzant un reduït conjunt de símbols connectats amb fletxes que marquen el flux d'execució. A la il·lustració 1 podem veure el programa dels exemples 1 i 2 representat en un organigrama. Veiem ara el significat de cadascun del símbols utilitzats.
2.3.1. Símbols dels organigrames
Fletxes Les fletxes es fan servir per connectar els diferents símbols de l'algoritme, indican quin és el següent símbol a executar desprès de l'actual. Les puntes de fletxa s'han de fer servir sempre que pugui haver confusió. Les fletxes només poden tenir un únic destí, mai més d'un o cap. Il·lustració 1 Organigrama del nostre programa d'exemple Inici "0 per parar." Introduir radi Radi= radi< area= mostra area Fi Si No Si No Area=proces(radi)
Fonaments d'informàtica Símbols d'Inici i Final Aquests símbols serveixen per a marcar l'inici del flux d'execució de l'algoritme i el final. Un algoritme només pot tenir un inici, però pot tenir cap, un o més finals. El final de fet és únic, però, de vegades és més aconsellable posar més d'un símbol i no un de sol amb un munt de fletxes que arriben de diferents llocs. Un algoritme que no té final és un procediment que sempre està funcionant. Per exemple, l'algoritme que descriu el funcionament de la barrera d'un pàrquing. El símbol d'inici no té fletxa d'entrada i només ha de tenir una fletxa de sortida. El símbol de final té una o més fletxes d'entrada i no té fletxa de sortida. Símbol de procés El símbol de procés indica les operacions que l'algoritme ha de fer per obtenir el resultat. Cada símbol pot representar una única operació o pot agrupar varies en un sol símbol. En aquest cas, les operacions s'han d'executar en l'ordre en que apareixen escrites de dalt a baix (encara que les fletxes indiquin que el fluxe d'execució entre símbols va d'abaix cap a dalt). Les operacions que s'indiquen han de ser operacions internes, és a dir, que no necessiten intervenció des de l'exterior de l'algoritme. El símbol té una o més fletxes d'entrada i només una de sortida. Il·lustració 3 Símbols d'Inici i Final Il·lustració 2 Fletxes. Il·lustració 4 Símbol de procés Inici Fi Procés
Fonaments d'informàtica Símbol de subalgoritme El símbol de subalgoritme es fa servir per referir-se dins d'un algoritme a un altre que ja tenim fet. De manera que simplifiquem el que estem fent ara. Les raons per fer subalgoritmes són diverses i ja les explicarem més endavant en aquest llibre. Llegint l'exemple 3 podrem comprendre millor el concepte de subalgoritme. És important entendre com és el flux d'execució quan trobem un símbol de subalgoritme. L'execució d'aquest símbol implica que el flux d'execució continua pel subalgoritme i que, a l'acabar aquest últim, es torna a l'algoritme principal per continuar per la següent operació o símbol. A la il·lustració 8 pot veure gràficament aquest comportament. Connectors De vegades, el nombre de fletxes que van d'un lloc a l'altre de l'organigrama pot provocar confusions. Per això podem reduir el nombre d'aquestes fletxes substituint-les per connectors. El connector rodó es fa servir per “ saltar ” dins la mateixa pàgina. Els connectors es numeren correlativament, tenint en compte que cada número ha de tenir dos connectors, l'origen i el destí. Exemple Per veure un exemple de subalgoritmes recuperem la comparació que hem fet abans entre un algoritme i una recepta de cuina. Suposem que volem fer un plat que necessita un sofregit de tomàquet i s'acompanya amb una salsa maionesa. És molt probable que tant el sofregit com la maionesa es facin servir a molts plats diferents i, per tant, el receptari expliqui com es fan en receptes separades. A la recepta del nostre plat només ens dirà que cal fer un sofregit i una salsa de maionesa, potser ens indiqui fins i tot la pàgina on trobarem cadascuna de les receptes, i, segurament, la indicació de quan s'ha de fer (possiblement el sofregit l'hagem de fer primer de tot i la salsa maionesa es pot fer en qualsevol moment). Podem considerar que la recepta del sofregit i la salsa maionesa són subalgoritmes ja que per si sols no constitueixen un plat i que, per tant, formen part de l'algoritme d'un plat. Exemple 3 Exemple de subalgoritmes Il·lustració 8 Comportament del flux d'execució amb subalgoritmes Il·lustració 7 Símbol de crida a subalgoritme Procés 1 Procés 2 Procés 3 Subalgoritme 1 Subalgoritme 1 Procés A Procés B Procés C Tornar
Subalgoritme
Algoritmes i programes Quan el flux d'execució arriba a un connector es continua per l'altre connector de la mateixa pàgina que té el mateix número. El connector no rodó es fa servir per “ saltar ” a un connector ubicat a un altre pàgina. A l'interior s'indica el número de la pàgina destí i el número del connector. El connector destí es un connector rodó normal. Altres símbols Amb els símbols que hem vist es poden representar tots els algoritmes. De vegades, però es fan servir altres símbols per facilitar la comprensió de l'algoritme. Per exemple, el símbols d'entrada/sortida es pot substituir per un símbol representatiu del dispositiu que es farà servir. Es freqüent la seva aparició quan el dispositiu no és l'habitual de monitor i teclat, si no que és una impressora, un disc, etc. Això, són símbols agafats dels diagrames de processos i importats als diagrames de flux. Altres vegades, farem servir petites derivacions dels símbols per guanyar en claredat. Un exemple seria el símbol de bifurcació amb més de dos fletxes de sortida. La condició també haurà ser un càlcul que doni més de dos possibles resultats. A la il·lustració 10 tenim un exemple d'aquesta variació de símbol de bifurcació.
2.3.2. Exemples d'organigrames
En aquesta secció veurem diversos exemples d'algoritmes fets mitjançant organigrames. Començarem amb un algoritme que no és gens informàtic, per veure que els algoritmes es poden fer servir en qualsevol àmbit de la nostra vida quotidiana. Cuinar un ou ferrat En aquest primer exemple veurem clarament que una recepta de cuina és un algoritme. Partim del moment en que l'usuari, el cuiner en aquest cas, ja té a mà els instruments (paella, cuina, encenedor, etc.). n n (^) p/n Connectors al origen Mateixa pàgina Entre pàgines Connector al destí
Algoritmes i programes Aquesta última opció és la que farem ja que es càlcul és molt senzill i no perdrem llegibilitat de l'algoritme, és a dir, s'entendrà fàcilment el que es vol fer. Saber si un nombre es primer o no. L'enunciat d'aquest problema és: “ Donat un nombre enter positiu major que zero, dir si és primer o no. Un nombre és primer si només és divisible per u i per si mateix. ” El mètode que farem servir per saber si un número és primer consistirà, precisament, en comprovar la pròpia definició. Es a dir, comprovarem que el número no és divisible per cap número comprès entre 1 i ell mateix (ambdós exclosos). Per això, anirem dividint el número, que a partir d'ara anomenarem N, per 2, 3, 4, 5, ..., fins a N-1. Si cap divisió es entera (o, dit d'altra manera, cap resta és zero) voldrà dir que N és primer. Si alguna divisió és entera (és a dir, la resta dóna zero) podrem dir que N no és primer. Fixem-nos, però que aquest mètode no funciona amb el número 1 ja que no hi ha cap número comprés entre 1 i N-1 (que és zero). I tampoc amb el número 2. Amb aquest dos números farem una excepció i directament direm que son primers. De totes maneres, es pot veure que no cal fer tantes divisions. Per exemple, si N no és divisible per 2 no ho serà per cap nombre parell. Així, podem dividir només per 2, 3, 5, 7, ..., fins a N-1 (o N-2 si N és imparell). També podem veure fàcilment, que no cal arribar fins a N-1 ja que qualsevol número entre N/2 i N que divideixi a N donarà com a resultat un número entre 1 i 2 ambdós exclosos i, per tant, la resta serà diferent de zero. Potser ja no és tant fàcil de veure però, de fet, quan arribem a la arrel quadrada d'N ja podrem concloure que N és primer. Resumint, el procediment a seguir serà:
- Si N és 1 o 2, N és primer.
- Si N és divisible per dos no és primer.
- A partir d'ara anirem dividint per 3, 5, 7, 9, ... fins l'arrel quadrada d'N. Si N és divisible per algun dels números no serà primer, en cas contrari si ho serà. A la il·lustració 13 podem veure l'algoritme complet. Observem que, als algoritmes de les il·lustracions 12 i 13 , fem ús del que anomenarem variables ( N i D ). En parlarem d'elles al capítol 3. Una diferència entre el pseudocodi i els organigrames és que el Il·lustració 12 És múltiple de tres? Inici Entrar un número i guardar-ho en N Resta(N/3) = 0 No (^) Sí Escriure "No és múltiple de 3"^ Escriure "És múltiple de 3" Inici
Fonaments d'informàtica primer fa explícita la definició i ús de variables, mentre que els organigrames només s'utilitzen i no es defineixen. En el disseny d'un programa és tant important un bon algoritme, com una bona definició de variables o, millor dit, unes bones estructures de dades. És per això, entre d'altres raons, que l'ús d'organigrames el restringirem a petits trossos de programes on les estructures de dades no siguin fonamentals. Il·lustració 13 N és primer? Inici Entrar N N és 1 o 2? Escriure "És primer" Resta(N/2) = 0? Escriure "No és primer" Sí No No Sí D <- 3 Resta(N/D) = 0? Sí No D <- D + 2 D <= Arrel(N) Sí No Fi
