ASIX-M3-UF2-Banc de Solucions

1. Regne de Dracs

En aquest joc, el jugador es troba en una terra de dracs. Els dracs viuen en coves i hi ha de dos tipus: els bons que volen compartir els seus tesors amb tu i els dolents molt cobdiciosos i afamats que no dubtaran a menjar-se tot aquell que provi d'accedir a la seva cova. El jugador es troba davant de dues coves, en una el drac amigable i en l'altre el drac dolent. El jugador a d'escollir...

• Mòduls a emprar:

from random import randint  # per distribuir els dracs en les coves aleatoriament
from time import sleep      # per fer més "emocionant" el final del joc

• El programa principal podria ser semblant a:

# Programa principal 
fiJoc = False
while not fiJoc:
    mostrarIntroduccio()
    numeroDeCova = escollirCova()
    explorarCova(numeroDeCova)
    jugarDeNuevo = jugar()

2. Construir un Quadrat màgic. Un quadrat màgic és una matriu quadrada (mateix nombre de files que de columnes), amb un nombre senar de files i columnes on la suma dels elements de totes les seves files i les seves columnes i les dues diagonals val igual. En aquest quadrat no hi ha cap número repetit, i els números que hi ha d'haver han d'anar des de 1 fins a n² on n és el numero de files i columnes.

Com construir-lo?

• El numero 1 el situarem en el quadrat superior al central (per exemple, per n=5, el quadrat central és (2,2) i el que està per sobre seu el (1,2).

• El següent número el situarem un quadrat a la dreta i un per sobre. Si un numero està a la posició (i,j), el següent el situarem en (i-1,j+1).

• Si resulta que al fer el moviment sortim per la dreta, entendrem que automàticament entrarem per l'esquerra, és a dir, és com si la matriu estigués enganxada la part esquerra amb la part dreta. El mateix passa amb dalt i baix. Si sortim per dalt, entrem per baix.

• A més ens podem trobar que la posició on toca anar un número ja es troba ocupada. Llavors el que farem és tornar a la posició on estàvem i fer el moviment que puja dos posicions (i-2, j ).

• Un exemple de quadrat màgic per a N=5 seria:

      23  6 19  2 15
      10 18  1 14 22
      17  5 13 21  9
       4 12 25  8 16
      11 24  7 20  3

• El programa tindrà les següents funcions:

llegirDimensio: Li demanem a l’usuari que ens indiqui la mida N de la matriu. Si el valor és correcte, la funció el retorna.

inicialitzarQuadrat: Simplement posem tots els valors a 0

calculaPosicioInicial: Segons la dimensió, calculem la primera posició

assignaValor: Posa un valor en una posició

calcularNovaPosicio: Retorna els valors de fila i columna vàlids per a col·locar el proper valor.

imprimirQuadrat: Treu per pantalla el quadrat màgic,

• El programa serà semblant a aquest :

dim = llegirDimensio()
qm = inicialitzarQuadrat(dim)
pos = calculaPosicioInicial(dim)
limit = dim*dim;
for valor in range(1,limit+1):
   assignaValor(qm,pos,valor)
   pos = calcularNovaPosicio(qm, dim, pos) 
imprimirQuadrat(qm)

3. El Penjat

El penjat consisteix en endevinar una paraula generada aleatòriament per l'ordinador. Dinàmica del joc:

• Es presenta una forca i un guio per a cada lletra de la paraula.
• El jugador proposa lletres (d'una en una) i:

• si la lletra es troba a la paraula es substitueixen els guions respectius per la lletra.
• sinó s'actualitza la forca en una part del cos (cap, tronc, braç esquerra, braç dret, cama esquerra i cama dreta).

• El joc finalitza quan es troben totes les lletres o quan ja no queden parts del cos.
• El programa permetre tornar a jugar si així o vol el jugador.
• Diagrama de flux

from random import randint
from os import system
from colorama import init, Fore, Back, Style
PENJAT = ['''
      +---+
      |   |
          |
          |
          |
          |
    =========''', '''
      +---+
      |   |
      O   |
          |
          |
          |
    =========''', '''
      +---+
      |   |
      O   |
      |   |
          |
          |
    =========''', '''
      +---+
      |   |
      O   |
     /|   |
          |
          |
    =========''', '''
      +---+
      |   |
      O   |
     /|\  |
          |
          |
    =========''', '''
      +---+
      |   |
      O   |
     /|\  |
     /    |
          |
    =========''', '''
      +---+
      |   |
      O   |
     /|\  |
     / \  |
          |
    =========''']
paraules = 'paraules donatius diccionari malaltia alemany escola impossible variable objectiu disseny reproductor escriptor llibertat revista llengua somni cistell maduixa gresca ignorant carquinyoli xisclar '.split()
 
def paraulaAleatoria(llistaParaules):
    # Retorna una paraula de forma aleatoria.
    indexParaula = randint(0, len(llistaParaules) - 1)
    return llistaParaules[indexParaula]
 
def mostrarForca(PENJAT, lletresIncorrectes, lletresCorrectes, paraulaEndevinar):
    system ("clear") 
    print ('EL PENJAT')
    print(Fore.RED+PENJAT[len(lletresIncorrectes)]+Fore.WHITE)
    print ("\n")
    espaiBlanc = " "
    print (Fore.RED+'Lletres incorrectes: '+Fore.WHITE, espaiBlanc)
    for lletra in lletresIncorrectes:
        print (Fore.RED+lletra+Fore.WHITE, espaiBlanc, end="")
    print ("\n")
    estatParaula = '_' * len(paraulaEndevinar)
    for i in range(len(paraulaEndevinar)): # Remplaça els espais en blanc per la lletra correcta
        if paraulaEndevinar[i] in lletresCorrectes:
            estatParaula = estatParaula[:i] + paraulaEndevinar[i] + estatParaula[i+1:]
    for lletra in estatParaula: # Mostra la paraula a endevinar amb espais entre les lletres
        print (Fore.GREEN+lletra+Fore.WHITE, espaiBlanc, end="")
    print ("\n")
 
def escollirLletra(algunalletra):
    # Retorna la lletra que proposa el jugador. Es controla que sigui una entrada correcta!
    while True:
        print ('Endivina una lletra:')
        lletra = input()
        lletra = lletra.lower()
        if len(lletra) != 1:
            print ('Només una lletra...') 
        elif lletra in algunalletra:
            print ('lletra repetida! Escull una altra lletra')
        elif lletra not in 'abcçdefghijklmnopqrstuvwxyz':
            print ('Només lletres...')
        else:
            return lletra
 
def jugar():
    # Demana si el jugador vol continuar jugant
    print ('Vols jugar de nou? (Sí o No)')
    return input().lower().startswith('s')
 
def quedin_intents(lletresIncorrectes):
    return len(lletresIncorrectes) < len(PENJAT) - 1

def comprovar_guanyar(lletresCorrectes, paraulaEndevinar):
    guanyat = True
    for i in range(len(paraulaEndevinar)):
        if paraulaEndevinar[i] not in lletresCorrectes:
            guanyat = False     
            break   
    return guanyat

fiJoc = False;
while not fiJoc:
    # Inicialitzar partida
    lletresIncorrectes = ""
    lletresCorrectes = ""
    paraulaEndevinar = paraulaAleatoria(paraules)
    guanyat = False
    mostrarForca(PENJAT, lletresIncorrectes, lletresCorrectes, paraulaEndevinar)
    while not guanyat and quedin_intents(lletresIncorrectes):
        # El jugador proposa una lletra
        lletra = escollirLletra(lletresIncorrectes + lletresCorrectes)
        if lletra in paraulaEndevinar:
            lletresCorrectes = lletresCorrectes + lletra
            # Es comprova si el jugador ha trobat totes les lletres de la paraula
            guanyat = comprovar_guanyar(lletresCorrectes, paraulaEndevinar)         
        else:
            lletresIncorrectes = lletresIncorrectes + lletra
            # Comprova si el jugador ha esgotat les oportunitats...
        mostrarForca(PENJAT, lletresIncorrectes, lletresCorrectes, paraulaEndevinar)
    if guanyat:
        print ('Molt bé! La paraula a endivinar era "' + paraulaEndevinar + '" Has guanyat!')
    else:
        print ('Has esgotat les oportunitats!\nDesprés de ' + str(len(lletresIncorrectes)) + ' lletras errònies i ' + str(len(lletresCorrectes)) + ' lletres correctes, la paraula a endivinar era "' + paraulaEndevinar + '"')
    # Vols continuar jugant?
    fiJoc = not jugar()