El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Del Problema a l'Algorisme

Següent ►
►

Tancàvem la lliçó anterior amb tascafacil.py funcionant i una limitació evident: tot el que fa és imprimir text fix, i canviar una dada obliga a editar el codi a mà. La temptació ara és llançar-se a aprendre sintaxi per arreglar-ho. La resistirem una lliçó més, perquè falta l'habilitat que de debò separa qui programa de qui copia codi: pensar la solució abans d'escriure-la.

Un programador amb pressa obre l'editor i comença a teclejar. Al cap de dues hores té codi que gairebé funciona, no sap per què falla i no pot explicar a ningú què fa. Un programador amb ofici dedica els primers vint minuts al paper: entén el problema, el descompon, escriu els passos i els comprova a mà. Després tecleja, i tecleja poc, perquè ja sap què escriurà.

En aquesta lliçó aprendràs què és exactament un algorisme, com descompondre un problema, com expressar una solució en pseudocodi i en diagrama de flux, i com verificar-la sense ordinador mitjançant una prova d'escriptori. Tot aplicat a dues operacions reals de TascaFàcil.

Apareixeran construccions com «repetir» o «si...aleshores»: aquí les farem servir només com a manera de pensar. Escriure-les en Python és assumpte dels mòduls 2 i 3.

Contingut

  1. Què és un algorisme
  2. Les cinc propietats d'un algorisme
  3. Descompondre un problema en passos i subproblemes
  4. Pseudocodi: convencions i exemple
  5. Diagrames de flux
  6. Prova d'escriptori: verificar sense ordinador
  7. Del pseudocodi al codi Python
  8. TascaFàcil: registrar una tasca nova
  9. TascaFàcil: quina tasca atén la Marta primer
  10. Errors comuns i consells
  11. Exercicis
  12. Conclusió

  1. Què és un algorisme

Un algorisme és una seqüència finita de passos precisos que, partint d'unes dades d'entrada, produeix un resultat en un temps finit.

La paraula sona tècnica, però el concepte és quotidià: una recepta de cuina, les instruccions de muntatge d'una prestatgeria i el procediment de la multiplicació que vas aprendre a l'escola són algorismes. Comparteixen l'essencial: passos ordenats, sense ambigüitat, que acaben i produeixen alguna cosa.

L'important és això: un algorisme és independent del llenguatge de programació. El mateix algorisme per ordenar una llista es pot escriure en Python, en Java o en paper; el que canvia és la notació, no la idea. Per això el que aprenguis aquí et servirà encara que canviïs de llenguatge deu vegades.

Concepte Què és Analogia
Problema El que cal resoldre «Vull un pastís»
Algorisme El mètode per resoldre'l La recepta
Programa L'algorisme escrit en un llenguatge executable La recepta traduïda a ordres per a un robot de cuina
Execució El programa funcionant amb dades concretes Fer el pastís dissabte

Confondre aquestes quatre coses és l'origen de molta frustració. «No em surt el programa» sol significar en realitat «no tinc clar l'algorisme», i això no s'arregla tocant codi.

  1. Les cinc propietats d'un algorisme

No tota llista de passos és un algorisme. Ha de complir cinc propietats.

1. Precís. Cada pas indica exactament què fer, sense marge d'interpretació.

  • Malament: «revisa les tasques importants».
  • Bé: «per a cada tasca, si la seva prioritat és alta i el seu estat és pendent, mostra-la per pantalla».

2. Definit (determinista). Amb les mateixes entrades produeix sempre les mateixes sortides. Si executes l'algorisme dues vegades amb les mateixes dades, el resultat és idèntic.

3. Finit. Acaba després d'un nombre finit de passos. Un algorisme que no acaba no és un algorisme, és un bucle infinit, i és un dels errors més habituals en començar.

  • Malament: «repeteix: compta una tasca més» (no acaba mai).
  • Bé: «repeteix mentre quedin tasques per revisar» (acaba, perquè les tasques són finites i a cada volta en queda una menys).

4. Amb entrada definida. Zero o més dades de partida, especificades amb claredat. A «registrar una tasca», l'entrada són el títol, la descripció, el responsable i la prioritat.

5. Amb sortida definida. Almenys un resultat observable: un valor, un missatge per pantalla, un fitxer modificat. Un algorisme que no produeix res observable no serveix de res.

Propietat Pregunta de control Si falla...
Precís Pot algú interpretar aquest pas de dues maneres? El programa farà alguna cosa inesperada
Definit Donarà sempre el mateix resultat amb les mateixes dades? Errors impossibles de reproduir
Finit Està garantit que acaba? El programa es penja
Entrada definida Quines dades necessito i d'on surten? Faltaran dades a mitja execució
Sortida definida Què produeix i com ho veig? Ningú no sabrà si va funcionar

Aplica aquestes cinc preguntes a qualsevol algorisme que escriguis. Detecten la majoria de les fallades abans que existeixin.

  1. Descompondre un problema en passos i subproblemes

La tècnica central per atacar qualsevol problema s'anomena descomposició: partir un problema gran en problemes més petits fins que cada peça sigui evident. Es resol cada peça per separat i després es combinen.

Aplicat a TascaFàcil, la petició inicial de la Marta era: «vull un programa per gestionar les tasques de l'estudi». Així, en bloc, és inabordable. Descomposta:

flowchart TD
    A["Gestionar les tasques d'Estudi Alba"] --> B["Registrar una tasca"]
    A --> C["Consultar tasques"]
    A --> D["Actualitzar tasques"]
    A --> E["Desar la informacio"]
    B --> B1["Demanar les dades"]
    B --> B2["Validar prioritat i responsable"]
    B --> B3["Afegir a la llista"]
    C --> C1["Llistar-les totes"]
    C --> C2["Filtrar per responsable"]
    C --> C3["Filtrar per estat"]
    D --> D1["Marcar com a completada"]
    D --> D2["Canviar responsable"]

Cada fulla de l'arbre és una tasca petita que sí que sabem abordar. «Marcar com a completada» és un problema manejable; «gestionar les tasques de l'estudi» no ho era.

La descomposició aporta tres avantatges concrets:

  • Progrés visible. Resoldre una fulla de l'arbre porta minuts, i veus avenç. Enfrontar-te al problema sencer produeix paràlisi.
  • Errors localitzats. Si falla el filtratge per responsable, saps exactament quina peça mirar.
  • Reutilització. «Validar prioritat» serveix tant en registrar una tasca com en modificar-la. Escriure-ho una vegada i fer-ho servir dues és la base del mòdul 4.

Un criteri pràctic per saber quan parar de descompondre: quan puguis explicar la peça en una frase i sàpigues com fer-la a mà. Si encara dubtes, continua partint.

  1. Pseudocodi: convencions i exemple

El pseudocodi és una manera d'escriure algorismes a mig camí entre el català i el codi: prou estructurat per no ser ambigu, prou lliure per no barallar-se amb la sintaxi.

No existeix un pseudocodi oficial. Aquestes són les convencions que farem servir al curs:

Element Notació Exemple
Inici i fi INICI / FI
Entrada de dades LLEGIR <dada> LLEGIR titol
Sortida de dades MOSTRAR <missatge> MOSTRAR "Tasca desada"
Assignar un valor <nom> ← <valor> comptador ← 0
Condició SI <cond> ALESHORES ... SINO ... FI SI
Repetició condicional MENTRE <cond> FER ... FI MENTRE
Repetició sobre elements PER A CADA <x> EN <llista> FER ... FI PER
Comentari // text // s'ignora en executar

Dues regles d'estil importants: indenta el contingut de cada bloc (facilita veure on comença i acaba) i tanca sempre els blocs (FI SI, FI MENTRE).

Exemple complet. Algorisme que calcula quantes tasques pendents té l'estudi:

INICI
    // Entrada: una llista de tasques, cadascuna amb el seu estat
    // Sortida: el nombre de tasques pendents

    pendents ← 0

    PER A CADA tasca EN llista_de_tasques FER
        SI estat de tasca = "pendent" ALESHORES
            pendents ← pendents + 1
        FI SI
    FI PER

    MOSTRAR "Tasques pendents: " + pendents
FI

Repassem les cinc propietats sobre aquest algorisme:

  • Precís: cada pas és inequívoc.
  • Definit: la mateixa llista produeix sempre el mateix nombre.
  • Finit: la llista té un nombre finit d'elements i cada volta en consumeix un.
  • Entrada definida: la llista de tasques amb els seus estats.
  • Sortida definida: un missatge amb el nombre de pendents.

Compleix les cinc. És un algorisme correcte, i ho hem verificat sense engegar l'ordinador.

  1. Diagrames de flux

Un diagrama de flux representa l'algorisme gràficament. És especialment útil quan hi ha decisions i camins alternatius, perquè es veuen d'un cop d'ull.

Els símbols bàsics:

Símbol Forma Significat
Inici / Fi Oval On comença i acaba
Procés Rectangle Una acció o càlcul
Decisió Rombe Una pregunta amb sortides Sí/No
Entrada / Sortida Romboide Llegir dades o mostrar resultats
Fletxa — Ordre en què s'avança

Exemple 1: la tasca és urgent? Un algorisme amb una sola decisió.

flowchart TD
    A(["INICI"]) --> B[/"LLEGIR prioritat de la tasca"/]
    B --> C{"prioritat = alta?"}
    C -->|Si| D[/"MOSTRAR: Atendre avui"/]
    C -->|No| E[/"MOSTRAR: Pot esperar"/]
    D --> F(["FI"])
    E --> F

Fixa't en dues coses: del rombe en surten exactament dues fletxes etiquetades, i tots dos camins tornen a unir-se abans del fi. Un diagrama amb camins que no acaben a FI està incomplet.

Exemple 2: comptar les tasques pendents. El mateix algorisme de l'apartat anterior, ara amb repetició.

flowchart TD
    A(["INICI"]) --> B["pendents ← 0"]
    B --> C["Situar-se a la primera tasca"]
    C --> D{"Queden tasques<br/>per revisar?"}
    D -->|No| H[/"MOSTRAR pendents"/]
    D -->|Si| E{"El seu estat es<br/>pendent?"}
    E -->|Si| F["pendents ← pendents + 1"]
    E -->|No| G["Passar a la seguent tasca"]
    F --> G
    G --> D
    H --> I(["FI"])

El bucle es veu com el que és: una fletxa que torna cap enrere, de G a D. I aquí hi ha la clau de la finitud: G avança a la tasca següent a cada volta, així que en algun moment la resposta a D serà «No». Si G no existís, el diagrama giraria per sempre. Aquesta fletxa de retorn és el bucle infinit fet visible, i és un bon motiu per dibuixar abans de programar.

Eina Quan convé
Pseudocodi Algorismes llargs, molts passos seqüencials, ja a prop del codi
Diagrama de flux Pocs passos però moltes decisions; explicar la lògica a una altra persona

A la pràctica es fan servir totes dues: el diagrama per entendre la forma general, el pseudocodi per al detall.

  1. Prova d'escriptori: verificar sense ordinador

La prova d'escriptori (o traçat) consisteix a executar l'algorisme a mà, amb dades concretes, anotant en una taula com canvia cada valor pas a pas. És la tècnica més infravalorada i més rendible de tot l'ofici: detecta errors de lògica en cinc minuts que a l'ordinador costarien una hora.

Tracem l'algorisme de comptar pendents amb aquestes dades d'Estudi Alba:

Núm. Tasca Responsable Estat
1 Logotip Forn Solé Luis pendent
2 Cartell fira del llibre Nuria completada
3 Redisseny web client Vidal Luis pendent
4 Pressupost març Marta pendent

I ara la taula de traçat. Una fila per volta del bucle, una columna per valor que ens interessa:

Volta Tasca examinada Estat És pendent? pendents després
— (inici) — — 0
1 Logotip Forn Solé pendent Sí 1
2 Cartell fira del llibre completada No 1
3 Redisseny web client Vidal pendent Sí 2
4 Pressupost març pendent Sí 3
— (fi: no queden tasques) — — 3

Sortida: Tasques pendents: 3. Comptant a ull a la taula de dades: la 1, la 3 i la 4. Correcte.

Com fer bé una prova d'escriptori:

  1. Tria dades petites però representatives. Quatre elements n'hi ha prou; amb quaranta et cansaràs i et saltaràs passos.
  2. Una columna per cada valor que canviï. Si hi ha tres variables, tres columnes.
  3. Una fila per pas o volta. Sense agrupar ni «anar més ràpid»: l'error sol ser precisament on un dóna alguna cosa per suposada.
  4. Sigues la màquina, no l'autor. No facis el que volies escriure, fes el que està escrit. Aquí és on apareixen els errors.
  5. Prova també els casos límit. I si la llista és buida? Amb el nostre algorisme, el bucle no s'executa cap vegada i la sortida és 0. Correcte. I si totes estan completades? També 0. Correcte.

Aquest últim punt mereix èmfasi: els casos límit són on viu la majoria dels errors reals. Llista buida, un sol element, tots iguals, valors repetits. Comprova'ls sempre.

  1. Del pseudocodi al codi Python

Quan l'algorisme està clar i traçat, traduir-lo a Python és gairebé mecànic. Vegem-ho amb un exemple que ja podem escriure sencer: mostrar la fitxa d'una tasca.

Pseudocodi:

INICI
    MOSTRAR "--- FITXA DE TASCA ---"
    MOSTRAR "Titol: Logotip Forn Sole"
    MOSTRAR "Responsable: Luis"
    MOSTRAR "Prioritat: alta"
    MOSTRAR "Estat: pendent"
FI

Python:

print("--- FITXA DE TASCA ---")
print("Titol: Logotip Forn Sole")
print("Responsable: Luis")
print("Prioritat: alta")
print("Estat: pendent")

La correspondència és directa: MOSTRAR es converteix en print, i el text va entre cometes dins dels parèntesis. INICI i FI no es tradueixen: en Python el programa comença a la primera línia i acaba a l'última.

Aquesta és la taula de traducció completa que anirem completant al llarg del curs:

Pseudocodi Python On s'estudia
MOSTRAR x print(x) Ja ho saps
LLEGIR x x = input() Entrada i sortida
x ← 5 x = 5 Variables
SI ... ALESHORES if ...: Condicionals
SINO else: Condicionals
MENTRE ... FER while ...: Bucles
PER A CADA x EN llista for x in llista: Bucles

De moment només tens la primera fila. En acabar el mòdul 3 les tindràs totes, i podràs traduir a Python qualsevol algorisme que escriguis en pseudocodi. Mentrestant, escriu pseudocodi sense por: l'algorisme és el que té valor, i traduir-lo serà el fàcil.

  1. TascaFàcil: registrar una tasca nova

Apliquem tot l'anterior al primer requisit de TascaFàcil (R1 i R2 de la llista de la primera lliçó): registrar una tasca amb les seves cinc dades, validant la prioritat.

El problema. La Marta vol apuntar un encàrrec nou. Cal demanar-li títol, descripció, responsable i prioritat; l'estat sempre comença com a «pendent». La prioritat només pot ser alta, mitjana o baixa: si escriu una altra cosa, cal tornar a preguntar.

Pseudocodi:

INICI
    // Entrada: dades teclejades per l'usuari
    // Sortida: la tasca registrada i un missatge de confirmacio

    MOSTRAR "--- NOVA TASCA ---"

    LLEGIR titol
    LLEGIR descripcio
    LLEGIR responsable

    // Validacio: repetir fins que la prioritat sigui valida
    prioritat_valida ← FALS
    MENTRE prioritat_valida = FALS FER
        MOSTRAR "Prioritat (alta / mitjana / baixa):"
        LLEGIR prioritat
        SI prioritat = "alta" O prioritat = "mitjana" O prioritat = "baixa" ALESHORES
            prioritat_valida ← VERTADER
        SINO
            MOSTRAR "Prioritat no valida. Torna-ho a provar."
        FI SI
    FI MENTRE

    estat ← "pendent"

    DESAR la tasca (titol, descripcio, responsable, prioritat, estat)
    MOSTRAR "Tasca registrada correctament."
FI

Diagrama de flux:

flowchart TD
    A(["INICI"]) --> B[/"LLEGIR titol, descripcio,<br/>responsable"/]
    B --> C[/"LLEGIR prioritat"/]
    C --> D{"prioritat es<br/>alta, mitjana o baixa?"}
    D -->|No| E[/"MOSTRAR: prioritat no valida"/]
    E --> C
    D -->|Si| F["estat ← pendent"]
    F --> G["DESAR la tasca"]
    G --> H[/"MOSTRAR: tasca registrada"/]
    H --> I(["FI"])

Fixa't en la fletxa que torna d'E a C: és el bucle de validació. Mentre la prioritat sigui incorrecta, es torna a preguntar. I és finit sempre que l'usuari acabi escrivint alguna cosa vàlida; si tecleja disbarats indefinidament, el programa preguntarà indefinidament. Això no és un error de l'algorisme: és una decisió de disseny que convé prendre conscientment. Una alternativa seria permetre tres intents i cancel·lar.

Prova d'escriptori. La Marta registra un encàrrec i s'equivoca en escriure la prioritat:

Pas Acció Valor introduït Estat de l'algorisme
1 LLEGIR titol «Targetes de visita Vidal» titol assignat
2 LLEGIR descripcio «300 uts, doble cara» descripcio assignada
3 LLEGIR responsable «Nuria» responsable assignat
4 LLEGIR prioritat «urgent» no és vàlida → missatge d'error
5 LLEGIR prioritat «ALTA» és vàlida?
6 LLEGIR prioritat «alta» vàlida → surt del bucle
7 estat ← pendent — estat = «pendent»
8 DESAR i MOSTRAR — «Tasca registrada correctament.»

El pas 5 revela un problema que la prova d'escriptori ha fet aflorar: «ALTA» en majúscules no coincideix amb «alta», perquè són textos diferents. L'algorisme, tal com està escrit, la rebutjaria. És el que volem? Gairebé segur que no: la Marta escriurà en majúscules la meitat de les vegades.

La correcció és senzilla —convertir el que s'ha introduït a minúscules abans de comparar— i l'aplicarem a Conversió de tipus i validació. El que és rellevant aquí és com hem trobat la fallada: amb una taula i un llapis, abans d'escriure ni una sola línia de Python. Trobar-la més tard, amb el programa ja escrit, hauria costat molt més.

  1. TascaFàcil: quina tasca atén la Marta primer

Segon algorisme, aquesta vegada de decisió. La Marta arriba el dilluns, té diverses tasques assignades i vol saber per quina començar.

La regla de negoci, acordada amb l'equip:

  1. Només compten les tasques pendents: les completades s'ignoren.
  2. Entre les pendents, guanya la de prioritat més alta (alta > mitjana > baixa).
  3. Si hi ha empat de prioritat, guanya la que es va registrar abans.

Fixa't que aquestes tres regles no se les inventa el programador: s'acorden amb qui té el problema. Escriure-les explícitament és part de la feina, i moltes vegades la primera vegada que l'equip es posa d'acord en una cosa que creia òbvia.

Pseudocodi:

INICI
    // Entrada: llista de tasques de la Marta, en ordre de registre
    // Sortida: la tasca que ha d'atendre primer

    triada ← CAP

    PER A CADA tasca EN tasques_de_marta FER

        SI estat de tasca = "completada" ALESHORES
            // no ens interessa, passem a la seguent
        SINO
            SI triada = CAP ALESHORES
                triada ← tasca
            SINO
                SI prioritat de tasca es major que prioritat de triada ALESHORES
                    triada ← tasca
                FI SI
                // si es igual o menor, es mante l'anterior:
                // aixi guanya la registrada abans en cas d'empat
            FI SI
        FI SI

    FI PER

    SI triada = CAP ALESHORES
        MOSTRAR "No tens tasques pendents."
    SINO
        MOSTRAR "Comenca per: " + titol de triada
    FI SI
FI

Diagrama de flux:

flowchart TD
    A(["INICI"]) --> B["triada ← CAP"]
    B --> C{"Queden tasques<br/>per revisar?"}
    C -->|No| J{"triada = CAP?"}
    C -->|Si| D{"Esta completada?"}
    D -->|Si| I["Passar a la seguent"]
    D -->|No| E{"triada = CAP?"}
    E -->|Si| F["triada ← tasca actual"]
    E -->|No| G{"La seva prioritat es major<br/>que la de triada?"}
    G -->|Si| F
    G -->|No| I
    F --> I
    I --> C
    J -->|Si| K[/"MOSTRAR: no hi ha pendents"/]
    J -->|No| L[/"MOSTRAR: comenca per triada"/]
    K --> M(["FI"])
    L --> M

Prova d'escriptori. Les tasques de la Marta, en ordre de registre:

Núm. Títol Prioritat Estat
1 Pressupost client Vidal mitjana pendent
2 Revisar factures febrer baixa completada
3 Trucar al Forn Solé alta pendent
4 Preparar reunió equip alta pendent

Traçat volta a volta:

Volta Tasca Completada? triada abans Substitueix? triada després
1 Pressupost Vidal (mitjana) No CAP Sí, no n'hi havia cap Pressupost Vidal
2 Revisar factures (baixa) Sí Pressupost Vidal No, s'ignora Pressupost Vidal
3 Trucar al Solé (alta) No Pressupost Vidal Sí: alta > mitjana Trucar al Solé
4 Preparar reunió (alta) No Trucar al Solé No: alta no és major que alta Trucar al Solé

Sortida: Comenca per: Trucar al Forn Solé.

Verifiquem que és correcte segons les regles acordades. Pendents n'hi ha tres: Pressupost (mitjana), Trucar al Solé (alta) i Preparar reunió (alta). De prioritat alta n'hi ha dues, i entre elles guanya la registrada abans, que és «Trucar al Solé» (número 3 davant del número 4). Coincideix amb el que produeix l'algorisme.

I els casos límit:

  • La Marta no té cap tasca. El bucle no s'executa, triada continua sent CAP i es mostra «No tens tasques pendents». Correcte.
  • Totes estan completades. Totes cauen per la branca que les ignora, triada continua sent CAP i surt el mateix missatge. Correcte.
  • Només una de pendent. S'assigna a la seva volta i cap no la substitueix. Correcte.

L'algorisme aguanta els quatre escenaris. Està a punt per implementar-se, i ho farem quan tinguem condicionals i bucles en Python.

Errors Comuns i Consells

Començar a teclejar sense haver pensat l'algorisme. És l'error més car. Si no saps explicar en veu alta quins passos farà el teu programa, no estàs a punt per escriure'l. Paper primer.

Passos ambigus. «Comprovar si la tasca és important» no és un pas: no diu què significa important. «Comprovar si la seva prioritat és alta» sí que ho és. Tota ambigüitat que deixis a l'algorisme reapareixerà com a error al programa.

Oblidar l'avenç dins d'un bucle. Si a cada volta no canvia res que acosti al final, el bucle és infinit. Al diagrama es veu de seguida: busca quina caixa fa progressar la condició del rombe. Si no la trobes, tens un problema.

Saltar-se els casos límit. Llista buida, un sol element, tots amb el mateix valor, tots completats. Un algorisme que només funciona amb el cas bonic no funciona.

Fer la prova d'escriptori «com a autor» i no «com a màquina». En traçar tendeixes a executar el que volies escriure, no el que vas escriure. És el parany més subtil. Truc: traça un algorisme teu de fa una setmana, o intercanvia'l amb una altra persona.

Donar per suposades regles de negoci. «Guanya la de prioritat més alta» sembla complet fins que dues tasques empaten. Escriu sempre què passa en els empats, en els buits i en les dades incorrectes. Preguntar-ho abans és barat; descobrir-ho en producció, no.

Creure que el pseudocodi ha de ser perfecte. No és un lliurable, és una eina de pensament. Ratlla'l, reescriu-lo, fes servir fletxes al marge. Si t'ajuda a pensar, està ben escrit.

Consell final: quan un programa et surti malament, no comencis canviant codi a veure si l'encertes. Torna a l'algorisme i fes-li una prova d'escriptori. En la majoria dels casos l'error no és a la sintaxi, és al raonament.

Exercicis

Exercici 1: Detectar propietats incomplertes

Per a cada algorisme, indica quina propietat o propietats incompleix i corregeix-lo:

a)

INICI
    MENTRE hi hagi tasques FER
        MOSTRAR "Hi ha tasques pendents"
    FI MENTRE
FI

b)

INICI
    LLEGIR prioritat
    SI la prioritat sembla urgent ALESHORES
        MOSTRAR "Atendre aviat"
    FI SI
FI

c)

INICI
    comptador ← 0
    PER A CADA tasca EN llista FER
        comptador ← comptador + 1
    FI PER
FI

Exercici 2: Algorisme i diagrama per comptar les tasques d'una persona

Escriu el pseudocodi i el diagrama de flux d'un algorisme que, donada la llista de tasques de l'estudi i el nom d'una persona, mostri quantes tasques pendents té assignades. Després, fes la prova d'escriptori amb aquestes dades, buscant les del Luis:

Núm. Títol Responsable Estat
1 Logotip Forn Solé Luis pendent
2 Cartell fira del llibre Nuria pendent
3 Redisseny web Vidal Luis completada
4 Manual de marca Solé Luis pendent
5 Pressupost març Marta pendent

Exercici 3: Reassignar una tasca

La Marta vol poder reassignar una tasca a una altra persona de l'equip. Les regles acordades són:

  • Només es poden reassignar tasques pendents; una de completada no es toca.
  • El nou responsable ha de ser Marta, Luis o Nuria.
  • No té sentit reassignar a la mateixa persona que ja la té: cal avisar.

Escriu el pseudocodi d'aquest algorisme i fes una prova d'escriptori per a aquests tres casos: (a) reassignar a la Nuria una tasca pendent del Luis, (b) intentar reassignar una tasca completada, (c) reassignar al Luis una tasca que ja és del Luis.

Solucions

Solució 1.

a) Incompleix la finitud. Res dins del bucle no redueix el nombre de tasques ni avança per la llista, així que la condició no deixa mai de complir-se: s'imprimiria el missatge eternament. A més no té sortida útil (repeteix el mateix sense informar de res). Correcció:

INICI
    pendents ← 0
    PER A CADA tasca EN llista FER
        SI estat de tasca = "pendent" ALESHORES
            pendents ← pendents + 1
        FI SI
    FI PER
    MOSTRAR "Tasques pendents: " + pendents
FI

b) Incompleix la precisió (i, per tant, el determinisme). «Sembla urgent» no és avaluable: dues persones ho interpretarien diferent i la màquina no ho pot interpretar en absolut. Correcció:

INICI
    LLEGIR prioritat
    SI prioritat = "alta" ALESHORES
        MOSTRAR "Atendre aviat"
    SINO
        MOSTRAR "Pot esperar"
    FI SI
FI

S'hi ha afegit el SINO perquè hi hagi sortida en tots dos casos.

c) Incompleix la sortida definida. Calcula correctament el comptador però no el mostra: el resultat es perd en acabar. Correcció: afegir MOSTRAR "Total de tasques: " + comptador abans de FI.

Solució 2.

Pseudocodi:

INICI
    // Entrada: llista de tasques i nom d'una persona
    // Sortida: nombre de tasques pendents d'aquesta persona

    LLEGIR persona
    comptador ← 0

    PER A CADA tasca EN llista_de_tasques FER
        SI responsable de tasca = persona I estat de tasca = "pendent" ALESHORES
            comptador ← comptador + 1
        FI SI
    FI PER

    MOSTRAR persona + " te " + comptador + " tasques pendents."
FI

Diagrama de flux:

flowchart TD
    A(["INICI"]) --> B[/"LLEGIR persona"/]
    B --> C["comptador ← 0"]
    C --> D{"Queden tasques<br/>per revisar?"}
    D -->|No| H[/"MOSTRAR persona i comptador"/]
    D -->|Si| E{"Es d'aquesta persona<br/>I esta pendent?"}
    E -->|Si| F["comptador ← comptador + 1"]
    E -->|No| G["Passar a la seguent"]
    F --> G
    G --> D
    H --> I(["FI"])

Prova d'escriptori buscant les del Luis:

Volta Tasca És del Luis? Pendent? Compta? comptador
— (inici) — — — 0
1 Logotip Forn Solé Sí Sí Sí 1
2 Cartell fira del llibre No Sí No 1
3 Redisseny web Vidal Sí No No 1
4 Manual de marca Solé Sí Sí Sí 2
5 Pressupost març No Sí No 2

Sortida: Luis te 2 tasques pendents. Verificat a ull: la 1 i la 4. La 3 és del Luis però està completada, i aquest és justament el cas que comprova que la condició doble funciona.

Solució 3.

INICI
    // Entrada: una tasca i el nom del nou responsable
    // Sortida: la tasca reassignada, o un missatge explicant per que no

    LLEGIR tasca
    LLEGIR nou_responsable

    SI estat de tasca = "completada" ALESHORES
        MOSTRAR "No es pot reassignar: la tasca ja esta completada."
    SINO
        SI nou_responsable NO ES "Marta" NI "Luis" NI "Nuria" ALESHORES
            MOSTRAR "Responsable no valid. Ha de ser Marta, Luis o Nuria."
        SINO
            SI nou_responsable = responsable de tasca ALESHORES
                MOSTRAR "La tasca ja esta assignada a " + nou_responsable
            SINO
                responsable de tasca ← nou_responsable
                MOSTRAR "Tasca reassignada a " + nou_responsable
            FI SI
        FI SI
    FI SI
FI

Prova d'escriptori:

Cas Tasca (responsable, estat) Nou responsable Comprovacions Resultat
a Logotip Solé (Luis, pendent) Nuria No completada → responsable vàlid → diferent de l'actual responsable ← Nuria. «Tasca reassignada a Nuria»
b Redisseny web Vidal (Luis, completada) Nuria Completada → es talla a la primera condició «No es pot reassignar: la tasca ja està completada.»
c Manual de marca (Luis, pendent) Luis No completada → responsable vàlid → igual a l'actual Sense canvis. «La tasca ja està assignada a Luis»

Observa l'ordre de les comprovacions: primer l'estat, després la validesa del nom i per últim la coincidència. Aquest ordre importa. Si comprovéssim primer si coincideix el responsable, una tasca completada assignada al Luis que s'intentés reassignar al Luis donaria el missatge equivocat. Decidir en quin ordre es fan les comprovacions és part del disseny de l'algorisme, no un detall.

Conclusió

Programar comença lluny del teclat. En aquesta lliçó has après que un algorisme és una seqüència finita de passos precisos que transformen una entrada en una sortida, independent del llenguatge en què s'escrigui, i que ha de complir cinc propietats: ser precís, definit, finit, amb entrada definida i amb sortida definida. Has vist com descompondre un problema gran en subproblemes manejables, com expressar la solució en pseudocodi amb convencions clares i com dibuixar-la en un diagrama de flux on els bucles es veuen com a fletxes que tornen enrere. I has practicat la tècnica més rendible de l'ofici: la prova d'escriptori, que amb una taula i un llapis troba errors que a l'ordinador costarien hores —com l'«ALTA» que no coincidia amb «alta».

Tot això aplicat a TascaFàcil: ja tenim dissenyats, verificats i amb els seus casos límit comprovats els algorismes de registrar una tasca nova i de decidir quina tasca atén la Marta primer. No són esbossos: són especificacions a punt per implementar.

Amb això tanquem el mòdul 1. Saps què és programar, d'on ve l'ofici, com es classifiquen i es trien els llenguatges, tens un entorn funcionant amb tascafacil.py al teu disc i saps dissenyar un algorisme abans d'escriure'l. És exactament l'equipatge que cal per començar a escriure codi de debò.

I cap allà anem ara. Al mòdul 2 deixem el paper i tornem a Python amb la peça que resol la limitació que arrosseguem des de la lliçó anterior —un programa que només imprimeix text fix—: les variables, que permeten desar dades i treballar-hi. Començarem per Variables i tipus de dades, on per fi el títol, el responsable i la prioritat d'una tasca deixaran d'estar escrits a mà dins d'un print i passaran a ser informació que el programa gestiona.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2026. Tots els drets reservats