Exercici 1: Disseny i ús de classes (2 punts)

Una colla castellera vol gestionar els assajos de les pinyes dels castells que fan. El rol dels castellers a la pinya pot ser de set tipus: baix (’B’), crossa (’X’), agulla (’A’), contrafort (’C’), mans (’M’), lateral (’L’) i vent (’V’).

Dissenyeu la classe Pinya que representa una pinya d'un castell. La classe ha de tenir dos atributs: nom, un string, i castellers, un diccionari en el que les claus són els rols de casteller (strings) i els valors el nombre de castellers d'aquell rol que calen per a fer el castell. Es demana que dissenyeu aquesta classe, que ha de disposar dels mètodes següents:

• __init__(self, nom_pinya): inicialitza la pinya assignant a l'atribut nom el valor del paràmetre nom_pinya i a l'atribut castellers un diccionari buit.
• __setitem__(self, rol, nombre): afegeix a la pinya nombre persones més corresponents al rol rol, modificant l'atribut castellers segons convingui.
• __getitem__(self, rol): retorna el nombre de castellers de la pinya corresponent al rol rol. Si el rol no és al diccionari retorna 0.
• __contains__(self, rol): retorna True si el rol és a la pinya i False en cas contrari.

Deseu la classe Pinya al mòdul ex1.py.

En el mateix mòdul ex1.py, dissenyeu la funció sobrers (pinya, lassistents) que donada una pinya pinya i una llista de rols assistents a un assaig lassistents, obté i retorna una llista amb els rols a lassistents que no són necessaris per fer la pinya pinya. Aquesta llista ha d'estar ordenada lexicogràficament.

Per exemple,

>>> import ex1
>>> p1 = ex1.Pinya('4de5')
>>> p1.nom
'4de5'
>>> p1['B']=3
>>> p1['X']=6
>>> p1['C']=4
>>> p1['X']=3
>>> p1['C']
4
>>> p1['X']
9
>>> p1['L']
0
>>> 'B' in p1
True
>>> 'M' in p1
False
>>> dassistents = ['B','X','A','C','M','L']
>>> ex1.sobrers (p1, dassistents)
['A', 'L', 'M']
>>> dassistents = ['B','X','C','M','V']
>>> ex1.sobrers (p1, dassistents)
['M', 'V']

Al fitxer test1.txt trobareu d'altres casos d'ús.

Exercici 2: Iteradors (2 punts)

Dissenyeu la funció genera_intervals(ini, fi) que donats dos iteradors d'enters, ini i fi, genera l'iterador amb tots els intervals no buits formats per un extrem inferior de ini i un extrem superior de fi. Els intervals són tuples de dos elements (einf, esup) on einf és l'extrem inferior i esup és l'extrem superior.

Observeu que l'exercici es pot resoldre calculant el producte cartesià dels iteradors ini i fi, i filtrant els intervals no buits, és a dir, els que l'extrem inferior és més petit que l'extrem superior. Recomanem usar el mòdul itertools i les funcions predefinides sobre iteradors.

No es poden usar llistes per resoldre aquest exercici (ni tuples de més de dos elements, ni diccionaris, ni cap altre estructura de dades).

La funció ha de passar, com a mínim, els doctests següents:

>>> from ex2 import genera_intervals

>>> i = (3, 1, 5)
>>> f = (4, 2)
>>> g = genera_intervals(i, f)
>>> iter(g) is g
True
>>> set(g) == {(3, 4), (1, 4), (1, 2)}
True

>>> i = iter((6, 3))
>>> f = [1, 4, 2]
>>> g = genera_intervals(i, f)
>>> iter(g) is g
True
>>> set(g) == {(3, 4)}
True

Disposeu de més doctests en el fitxer test2.txt.

Deseu la funció al fitxer ex2.py.

Exercici 3: Recursivitat (2 punts)

Donada una llista de nombres l, definim les diferències de l com la llista de les restes de cada dos nombres consecutius de l (el primer menys el segon, el segon menys el tercer, etc).

En primer lloc, es demana que utilitzeu la recursivitat per a dissenyar la funció diferencies(l) que, donada una llista de nombres enters, amb almenys dos elements, retorni la llista de diferències de l. Aquesta funció ha de passar els següents doctests:

>>> diferencies([10, 2])
[8]
>>> diferencies([7, 2, 3, 11, 8])
[5, -1, -8, 3]
>>> diferencies([1, 38, 3, -8, 2, 4, 10])
[-37, 35, 11, -10, -2, -6]

Fixeu-vos que el procés d'obtenció de les diferències d'una llista de nombres es pot repetir fins a obtenir una llista amb un sol nombre. Per exemple:

[3, 1, 10, 6] --> [2, -9, 4] --> [11, -13] --> [24]

En segon lloc, es demana que dissenyeu la funció recursiva red_dif(l) que, donada una llista de nombres enters, retorna un altre enter, el resultat de calcular les diferències a la llista l tantes vegades com es pugui (és a dir, fins a obtenir un sol nombre). Aquesta funció ha de passar els següents doctests:

>>> red_dif([10, 2])
8
>>> red_dif([3, 1, 10, 6])
24
>>> red_dif([7, 2, 3, 11, 8])
-19
>>> red_dif([1, 38, 3, -8, 2, 4, 10])
-6

Deseu les dues funcions al fitxer ex3.py.

Exercici 4: Grafs (2 punts)

En un joc de rol, hem representat les diferents zones de l'escenari i la forma com estan connectades mitjançant un graf (no dirigit): les zones són els nodes graf, i una aresta des de `a` fins a `b` indica que els jugadors poden anar de la zona `a` a la zona `b`. Per exemple, la següent figura representa un escenari amb nou zones:

Es demana que, al mòdul ex4.py, escriviu la funció ruta_alternativa(g, a, b, c) que, donat un graf de networkx que representa l'escenari d'un joc, i tres nodes (strings), retorni el camí més curt per anar des de a fins a b que no passi per c. El camí retornat ha de ser una llista de nodes. Si hi ha més d'un camí possible igual de curt, tant és el camí que es retorni. Si un dels nodes a o b no és del graf o bé si el camí demanat és impossible, la funció ha de retornar la llista buida.

Per exemple,

>>> g = nx.Graph()
>>> g.add_nodes_from(['taberna','poble','cova','platja','vaixell','prat','bosc','muntanya','port'])
>>> g.add_edges_from([ ('poble','taberna'), ('poble','bosc'), ('bosc','muntanya'), ('muntanya','prat') ])
>>> g.add_edges_from([ ('poble','platja'), ('platja','vaixell'), ('platja','cova') ])
>>> g.add_edges_from([ ('poble','prat'), ('platja','prat') , ('port','poble'), ('port', 'vaixell') ])

>>> ruta_alternativa(g, 'muntanya', 'cova', 'prat')
['muntanya', 'bosc', 'poble', 'platja', 'cova']
>>> ruta_alternativa(g, 'port', 'bosc', 'poble')
['port', 'vaixell', 'platja', 'prat', 'muntanya', 'bosc']
>>> ruta_alternativa(g, 'taberna', 'prat', 'poble')
[]

Fixeu-vos que una forma de calcular el camí més curt de a fins a b que no passi per c, n'hi ha prou amb calcular un nou graf idèntic a l'original però sense el node c i trobar el camí més curt en aquest nou graf. Si utilitzeu aquesta estratègia, aneu amb compte que la funció ruta_alternativa(g, a, b, c) no pot modificar el graf g.

El fitxer test4.txt conté d'altres jocs de proves.

Exercici 5: PyGame (2 punts)

Es vol fer un joc d'atzar en el que un usuari podrà obrir i tancar capses clicant a sobre per descobrir quin regal tenen a dins. Disposeu del script main.py que crea l'àrea gràfica, dues capses i recull el clic d'usuari. Només haureu de dissenyar la classe Capsa. Aquesta classe ha d'heretar de pygame.sprite.Sprite. Ha de tenir cinc atributs: ima_oberta i ima_tancada que són les imatges (instàncies a la classe pygame.Surface) corresponents a l'estat obert i tancat respectivament de la capsa; un booleà tancada que té per valor True si la capsa està tancada i False si està oberta i els atributs habituals image i rect.

1. Dissenyeu el mètode __init__(self, ima_oberta, ima_tancada, centre). Aquest mètode haurà de crear una instància a la classe Capsa. Els atributs ima_oberta i ima_tancada s'inicialitzaran amb els valors dels paràmetres del mateix nom; l'atribut tancada tindrà per valor inicial True, l'atribut image s'inicialitzarà amb la imatge tancada i l'atribut rect tindrà les mides de les imatges (que són les mateixes en tots dos estats) i estarà centrat en la posició indicada pel paràmetre centre.
2. Dissenyeu el mètode obrirotancar(self) que canvia l'estat de la capsa de tancada a oberta i d'oberta a tancada. Per fer-ho, cal canviar el valor de l'atribut tancada i assignar a l'atribut image la imatge corresponent al nou estat.

Disposeu de jocs de prova en els fitxers test5-1.txt i test5-2.txt.

Deseu la classe al fitxer ex5.py.