Diferència entre revisions de la pàgina «ASIX-M3-UF2-Banc de Solucions»

De wikiserver
Dreceres ràpides: navegació, cerca
(Es crea la pàgina amb «1. 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...».)
 
 
(Hi ha 30 revisions intermèdies del mateix usuari que no es mostren)
Línia 1: Línia 1:
−
1. 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
+
==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:
 +
<source lang=python>
 +
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
 +
</source>
 +
<!--
 +
:* El programa principal podria ser semblant a:
 +
<source lang=python>
 +
# Programa principal
 +
fiJoc = False
 +
while not fiJoc:
 +
    mostrarIntroduccio()
 +
    numeroDeCova = escollirCova()
 +
    explorarCova(numeroDeCova)
 +
    jugarDeNuevo = jugar()
 +
</source>
 +
 
 +
<source lang=python>
 +
from random import randint
 +
from time import sleep
 +
 
 +
# Explicaciíó del joc
 +
def mostrarIntroduccio():
 +
    print ( "Et trobes en terres desconegudes habitades per dracs.")
 +
    print ( "Arribes davant de dues coves. En una viu, un drac generós i")
 +
    print ( "amigable i compartirà el seu tresor amb tu. En L'altre hi viu un drac")
 +
    print ( "cobdiciós i afamat, i et devorarà immediatament.")
 +
 
 +
# Elecció de la cova per part del jugador
 +
def escollirCova():
 +
    cova = ''
 +
    while cova != '1' and cova != '2':
 +
        cova = input('A quina cova vols accedir? (1 ó 2)')
 +
    return cova
 +
 
 +
# Es generà aleatoriament la cova on habiten els respectius dracs i el resultat és ...
 +
def explorarCova(covaEscollida):
 +
    print ( "T'aproximes a la cova ...")
 +
    sleep (2)
 +
    print ( "És fosca i esgarrifosa ...")
 +
    sleep (2)
 +
    print ( "Un gran drac apareix sobtadament davant teu! Obre la boca i ...")
 +
    print ()
 +
    sleep (2)
 +
    covaAmigable = randint(1, 2)
 +
    if covaEscollida == str(covaAmigable):
 +
        print("Et regala un tresor!")
 +
    else:
 +
        print("T'engulleix d'una queixelada!")
 +
 
 +
# Es demana al jugador si volo continuar jugant
 +
def jugar():
 +
    tornarAJugar = input('Vols jugar de nou? (Sí o No)')
 +
    return not tornarAJugar.lower().startswith('s')
 +
 
 +
# Programa principal
 +
fiJoc = False
 +
while not fiJoc:
 +
    mostrarIntroduccio()
 +
    numeroDeCova = escollirCova()
 +
    explorarCova(numeroDeCova)
 +
    fiJoc = jugar()
 +
</source>
 +
-->
 +
 
 +
==Quadrat màgic==
 +
 
 +
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<sup>2</sup> on n és el numero de files i columnes.
 
des de 1 fins a n<sup>2</sup> on n és el numero de files i columnes.
  
Línia 37: Línia 108:
 
limit = dim*dim;
 
limit = dim*dim;
 
for valor in range(1,limit+1):
 
for valor in range(1,limit+1):
−
   assignaValor(qm,pos,valor)
+
   qm = assignaValor(qm,pos,valor)
 
   pos = calcularNovaPosicio(qm, dim, pos)  
 
   pos = calcularNovaPosicio(qm, dim, pos)  
 
imprimirQuadrat(qm)
 
imprimirQuadrat(qm)
 
</source>
 
</source>
−
 
+
<!--
 
<source lang=python>
 
<source lang=python>
 
def llegirDimensio():
 
def llegirDimensio():
Línia 70: Línia 141:
  
 
def assignaValor(qm, pos, valor):
 
def assignaValor(qm, pos, valor):
−
        qm[pos[0]][pos[1]] = valor
+
    qm[pos[0]][pos[1]] = valor
 +
    return qm
  
 
def calcularNovaPosicio(qm, dim, pos):  
 
def calcularNovaPosicio(qm, dim, pos):  
−
        columnaAux = (pos[1]+1)%dim  
+
    columnaAux = (pos[1]+1)%dim  
−
        filaAux = pos[0] - 1
+
    filaAux = pos[0] - 1
 +
    if (filaAux < 0):
 +
        filaAux = dim - 1
 +
 
 +
    if (qm[filaAux][columnaAux] != 0):
 +
        # lloc ja ocupat
 +
        filaAux-=1
 
         if (filaAux < 0):
 
         if (filaAux < 0):
 
             filaAux = dim - 1
 
             filaAux = dim - 1
−
 
+
         columnaAux=pos[1]                   
−
         if (qm[filaAux][columnaAux] != 0):
+
    return (filaAux,columnaAux)
−
          # lloc ja ocupat
 
−
            filaAux-=1
 
−
            if (filaAux < 0):
 
−
                filaAux = dim - 1
 
−
            columnaAux=pos[1]                   
 
−
        return (filaAux,columnaAux)
 
  
 
dim = llegirDimensio()
 
dim = llegirDimensio()
Línia 91: Línia 163:
 
limit = dim*dim;
 
limit = dim*dim;
 
for valor in range(1,limit+1):
 
for valor in range(1,limit+1):
−
   assignaValor(qm,pos,valor)
+
   qm = assignaValor(qm,pos,valor)
 
   pos = calcularNovaPosicio(qm, dim, pos)  
 
   pos = calcularNovaPosicio(qm, dim, pos)  
 
imprimirQuadrat(qm)
 
imprimirQuadrat(qm)
 
</source>
 
</source>
 +
-->
 +
 +
==Mastermind==
 +
 +
El Mastermind és un joc que consisteix en, mitjançant pistes, deduir un codi numèric de n xifres ocult (en el nostre cas de quatre xifres i generat aleatòriament). Dinàmica del joc:
 +
 +
:* El programa generà aleatòriament un codi numèric de quatre xifres (codi a endevinar).
 +
:* El jugador anirà proposant codis (intents) per tal de trobar el codi a endevinar.
 +
:* L'objectiu es trobar el codi en el menor número d'intents. Es pot limitar el número d'intents (per ex. a 7).
 +
:* Desprès de cada intent el programa donarà pistes que ajudin a deduir el codi:
 +
::* '''Encerts''': quants números s'han encertat i es troben en la posició correcta .
 +
::* '''Coincidències''': quants números s'han encertat però no es troben en la posició correcta.
 +
:* Exemple:
 +
::* codi: 7539
 +
::* proposta: 2590
 +
::* pistes: 1 encert i 1 coincidència.
 +
:* El joc finalitzarà quan s'hagi trobat el codi numèric o s'hagin exhaurit els intents.
 +
:* El programa permetrà tornar a jugar si així o vol el jugador.
 +
:* Diagrama de flux
 +
 +
[[Imatge:m3_uf2_diagrama_flux_mastermind.png |400px|center| Diagrama flux "Mastermind"]]
 +
 +
<!--
 +
<source lang=python>
 +
# ARXIU: [mastermind.py]
 +
 +
# mòdul que permet escollir números aleatoriament
 +
from random import choice
 +
 +
# conjunt de dígits
 +
digits = ('0','1','2','3','4','5','6','7','8','9')
 +
 +
def presentacio_joc():
 +
    print ("Benvingut/da al Mastermind!")
 +
    print ("Has d'endivinar un numero de", 4, "xifres diferents")
 +
 +
# generem el número a endivinar de forma aleatoria
 +
def generar_combinacio():
 +
    codi = ''
 +
    for i in range(4):
 +
        candidat = choice(digits)
 +
        # comprovem que els dígits no es repeteixin
 +
        while candidat in codi:
 +
            candidat = choice(digits)
 +
        codi = codi + candidat
 +
    return codi
 +
 +
# comprovem que encara queden intents
 +
def quedin_intents(intents, MAXINTENTS):
 +
    return intents<MAXINTENTS
 +
 +
def resultat_proposta(codi, proposta):
 +
    encerts = 0
 +
    coincidencies = 0
 +
    for i in range(4):
 +
        if proposta[i] == codi[i]:
 +
            encerts = encerts + 1
 +
        elif proposta[i] in codi:
 +
            coincidencies = coincidencies + 1
 +
    print ("La proposta (", proposta, ") té", encerts, \
 +
          "encerts i ", coincidencies, "coincidencies.")
 +
#    return encerts, coincidencies
 +
   
 +
def introdueix_proposta():
 +
 +
    def verificar_digits(proposta,digits):
 +
        for i in range(len(proposta)):
 +
            if proposta[i] not in digits:
 +
              return False
 +
        return True
 +
 +
    def numeros_diferents(proposta):
 +
        aux=''
 +
        for i in range(len(proposta)):
 +
            if proposta[i] not in aux:
 +
                aux += proposta[i]
 +
        return len(aux) == len(proposta)
 +
 +
    while True:
 +
      proposta = input("Qunina combinació proposes?: ")
 +
      if len(proposta)!=4:
 +
          print ("són 4 números")
 +
      elif not verificar_digits(proposta, digits):
 +
          print ("Només s'admeten números")
 +
      elif not numeros_diferents(proposta):
 +
          print ("Els números han de ser diferents")
 +
      else:
 +
          break;
 +
    return proposta
 +
 +
def jugar():
 +
    # Demana si el jugador vol continuar jugant
 +
    print ('Vols jugar de nou? (Sí o No)')
 +
    return input().lower().startswith('s')
 +
 +
# procesamos las propuestas e indicamos aciertos y coincidencias
 +
MAXINTENTS = 10
 +
fiJoc = False
 +
while not fiJoc:
 +
    presentacio_joc()
 +
    codi = generar_combinacio()
 +
    intents = 1
 +
    proposta = introdueix_proposta()
 +
    encertat = codi == proposta
 +
    while not encertat and quedin_intents(intents, MAXINTENTS):
 +
        resultat_proposta(codi, proposta)
 +
        intents = intents + 1
 +
        proposta = introdueix_proposta()
 +
        encertat = codi == proposta
 +
    if encertat:
 +
        print ("Enhorabona! Has encertat el codi en", intents, "intents.")
 +
    else:
 +
      print ("Has esgotat els %d intents. Ho sento!" %MAXINTENTS)
 +
    fiJoc = not jugar()   
 +
</source>
 +
-->
 +
 +
==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 permetrà tornar a jugar si així o vol el jugador.
 +
:* Diagrama de flux
 +
 +
[[Imatge:m3_uf2_diagrama_flux_el_penjat.png |400px|center| Diagrama flux "El Penjat"]]
 +
<!--
 +
<source lang=python>
 +
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()
 +
</source>
 +
-->
 +
 +
==3 en ratlla==
 +
 +
El joc consisteix en posar 3 fitxes en línia en un tauler de 9 caselles abans que ho faci l'ordinador.
 +
 +
:* El jugador i l'ordinador alternen les jugades.
 +
:* El jugador escollirà el símbol que vol (X o O) i es farà un sorteig de qui comença la partida
 +
:* L'ordinador analitzarà la situació del tauler per cercar la millor jugada a fer.
 +
:* La partida finalitzarà en el moment que un dels jugadors aconsegueixi fer 3 fitxes en linia o quan el tauler estigui omplert.
 +
:* Cal informar del resultat de la partida: Guanya la persona, l'oridnador o hi ha hagut un empat.
 +
:* El programa permetrà tornar a jugar si així o vol el jugador.
 +
 +
<!--
 +
<source lang=python>
 +
# Ta Te Ti https://inventwithpython.com/es/
 +
 +
import random
 +
from os import system
 +
 +
 +
 +
def dibuixarTauler(tauler):
 +
 +
    # Aqiesta fimcoó dibuixa el tauler del joc
 +
 +
    system("clear")
 +
 +
    # "tauler" és una llista de 10 cadenes (obviem la posició 0 de la llista)
 +
 +
    print(' 3 en ratlla')
 +
    print()
 +
    print('  |  |')
 +
    print(' ' + tauler[7] + ' | ' + tauler[8] + ' | ' + tauler[9])
 +
    print('  |  |')
 +
    print('-----------')
 +
    print('  |  |')
 +
    print(' ' + tauler[4] + ' | ' + tauler[5] + ' | ' + tauler[6])
 +
    print('  |  |')
 +
    print('-----------')
 +
    print('  |  |')
 +
    print(' ' + tauler[1] + ' | ' + tauler[2] + ' | ' + tauler[3])
 +
    print('  |  |')
 +
 +
 +
def escollirSimbolJugador():
 +
 +
    # Permet al jugador escollir el símbol en el que vol jugar.
 +
 +
    # Retorna una llista, en la posició 0 el símbol del jugador i en la 1 el de l'ordinador.
 +
 +
    simbol = ''
 +
    while not (simbol == 'X' or simbol == 'O'):
 +
        print('Escull símbol: X o O?')
 +
        simbol = input().upper()
 +
    if simbol == 'X':
 +
        return ['X', 'O']
 +
    else:
 +
        return ['O', 'X']
 +
 +
def jugadorInici():
 +
    # L'atzar decideix quin jugador comença.
 +
 +
    if random.randint(0, 1) == 0:
 +
        return 'Ordinador'
 +
    else:
 +
        return 'Jugador'
 +
 +
def simbolTorn(torn, simbolJugador, simbolOrdinador):
 +
   
 +
    # Retorna el simobol del que comenci.
 +
 +
    if torn == 'Jugador':
 +
        return simbolJugador
 +
    else:
 +
        return simbolOrdinador
 +
 +
def iniciJoc():
 +
    simbolJugador, simbolOrdinador = escollirSimbolJugador() 
 +
    tornInici = jugadorInici()
 +
    simbolInici = simbolTorn(tornInici, simbolJugador, simbolOrdinador)
 +
    return [tornInici, simbolInici]
 +
 +
def jugarDeNou():
 +
 +
    # Retorna True si el jugador vol jugar un altre cop, en cas contrari retorna False.
 +
 +
    print('Vols jugar de nou? (sí/no)?')
 +
    return input().lower().startswith('s')
 +
 +
 +
def ferJugada(tauler, simbol, jugada):
 +
 +
    tauler[jugada] = simbol
 +
 +
 +
def jugadaGuanyadora(tauler, simbol):
 +
 +
    # Donat un tauler i un símbol, retorna True si ha trobat el símbol en la mateixa línia o diagonal.
 +
 +
    return ((tauler[7] == simbol and tauler[8] == simbol and tauler[9] == simbol) or # horitzontal superior
 +
            (tauler[4] == simbol and tauler[5] == simbol and tauler[6] == simbol) or # horitzontal mitja
 +
            (tauler[1] == simbol and tauler[2] == simbol and tauler[3] == simbol) or # horitzontal inferior
 +
            (tauler[7] == simbol and tauler[4] == simbol and tauler[1] == simbol) or # vertical esquerra
 +
            (tauler[8] == simbol and tauler[5] == simbol and tauler[2] == simbol) or # vertical mitja
 +
            (tauler[9] == simbol and tauler[6] == simbol and tauler[3] == simbol) or # vertical dreta
 +
            (tauler[7] == simbol and tauler[5] == simbol and tauler[3] == simbol) or # diagonal
 +
            (tauler[9] == simbol and tauler[5] == simbol and tauler[1] == simbol))  # diagonal
 +
 +
 +
def obtenirDuplicatTauler(tauler):
 +
 +
    # Duplica la llista del taulr i retorna el duplicat.
 +
 +
    dupTauler = []
 +
    for element in tauler:
 +
        dupTauler.append(element)
 +
    return dupTauler
 +
 +
 +
def espaiLliure(tauler, jugada):
 +
 +
    # Retorna True si hi ha espai per fer la jugada en el tauler.
 +
 +
    return tauler[jugada] == ' '
 +
 +
 +
def obtenirJugadaJugador(tauler):
 +
 +
    # Permet al jugador introduir una jugada i la vàlida.
 +
 +
    jugada = ' '
 +
    while jugada not in '1 2 3 4 5 6 7 8 9'.split() or not espaiLliure(tauler, int(jugada)):
 +
        print('Jugada? (1-9)')
 +
        jugada = input()
 +
    return int(jugada)
 +
 +
 +
def jugadaAtzar(tauler, llistaJugades):
 +
 +
    # Retorna una jugada vàlida de les possibles (llistaJugades).
 +
 +
    # Retorna None si ho ha cap jugada vàlida.
 +
 +
    jugadesPossibles = []
 +
    for casella in llistaJugades:
 +
        if espaiLliure(tauler, casella):
 +
            jugadesPossibles.append(casella)
 +
    if len(jugadesPossibles) != 0:
 +
        return random.choice(jugadesPossibles)
 +
    else:
 +
        return None
 +
 +
 +
def obtenirJugadaOrdinador(tauler, simbolOrdinador):
 +
 +
    # Donat un tauler i el símbol de l'ordinador, determina la jugada a fer.
 +
 +
    if simbolOrdinador == 'X':
 +
        simbolJugador = 'O'
 +
    else:
 +
        simbolJugador = 'X'
 +
 +
    # Algoritme d'IA (Inteligència Artifical) del 3 en ratlla.
 +
 +
    # Primer, verifica si pot guanyar en la propera.
 +
 +
    for casella in range(1, 10):
 +
        copiaTauler = obtenirDuplicatTauler(tauler)
 +
        if espaiLliure(copiaTauler, casella):
 +
            ferJugada(copiaTauler, simbolOrdinador, casella)     
 +
            if jugadaGuanyadora(copiaTauler, simbolOrdinador):
 +
                return casella
 +
 +
 +
    # Verifica si el jugador podria guanya en la propera jugada, i bloqueja la casella.
 +
 +
    for casella in range(1, 10):
 +
        copiaTauler = obtenirDuplicatTauler(tauler)
 +
        if espaiLliure(copiaTauler, casella):
 +
            ferJugada(copiaTauler, simbolJugador, casella)     
 +
            if jugadaGuanyadora(copiaTauler, simbolJugador):
 +
                return casella
 +
 +
    # Intenta ocupar una de les cantonades lliures.
 +
 +
    jugada = jugadaAtzar(tauler, [1, 3, 7, 9])
 +
    if jugada != None:
 +
        return jugada
 +
 +
 +
    # De estar lliure, intenta ocupar la casella central.
 +
 +
    if espaiLliure(tauler, 5):
 +
        return 5
 +
 +
 +
    # Ocupa aleatoriament un dels costats.
 +
 +
    return jugadaAtzar(tauler, [2, 4, 6, 8])
 +
 +
def obtenirJugada(tauler, torn):
 +
    if torn[0] == 'Jugador':
 +
        jugada = obtenirJugadaJugador(tauler)
 +
    else:
 +
        jugada = obtenirJugadaOrdinador(tauler, torn[1])
 +
    return jugada
 +
 +
def canviTorn(torn):
 +
    if torn[0] == 'Jugador':
 +
      torn[0] = 'Ordinador'
 +
    else:
 +
      torn[0] = 'Jugador'
 +
    if torn[1] == 'X':
 +
      torn[1] = 'O'
 +
    else:
 +
      torn[1] = 'X'
 +
 +
 +
def missatgeFiPartida(resultat):
 +
    if resultat == 'Jugador':
 +
        print('Enhorabona, has guanyat!')
 +
    elif resultat == 'Ordinador':
 +
        print("L'ordinador t'ha vençut! Has perdut.")
 +
    else:
 +
        print('Empat!')
 +
 +
# Programa principal
 +
 +
print('Benvingut al 3 en ratlla!')
 +
 +
jugar = True
 +
while jugar:
 +
 +
    # Reseteja el tauler
 +
   
 +
    MAXJUGADES = 9
 +
    tauler = [' '] * 10
 +
    dibuixarTauler(tauler)
 +
 +
   
 +
    # torn: llista on posició 0 conté qui li toca jugar ara i posició 1 símbol corresponent
 +
    torn = iniciJoc()
 +
 +
    hihaGuanyador = False
 +
    jugades = 0
 +
    print(torn[0] + ' comença el joc.')
 +
    while not hihaGuanyador and jugades < MAXJUGADES:
 +
        jugada = obtenirJugada(tauler,torn)
 +
        ferJugada(tauler, torn[1], jugada)
 +
        jugades += 1
 +
        dibuixarTauler(tauler)
 +
        if jugadaGuanyadora(tauler, torn[1]):
 +
            hihaGuanyador = True
 +
        else:
 +
            canviTorn(torn)
 +
    if hihaGuanyador:
 +
        missatgeFiPartida(torn[0])
 +
    else:
 +
        missatgeFiPartida('Empat')
 +
    jugar = jugarDeNou()
 +
</source>
 +
-->
 +
 +
==Recursivitat==
 +
<!--
 +
0. Fes un meńu per escollir l'exercici a executar: el menú es trobarà en un fitxer diferent dels exercicis i aquests s'ubicaran en el mateix mòdul.
 +
 +
<source lang="python">
 +
from recursivitat import * #Importem totes les funcions explícites del mòdul recursivitat
 +
 +
def menu(*args):
 +
    opcions = []
 +
    print("")
 +
    for opcio in args:
 +
        print(opcio)
 +
        opcions.append(opcio[:1])
 +
    print("")
 +
    op = input("Escull opció: ")
 +
    while op not in opcions:
 +
        op = input("Escull opció: ")
 +
    return op
 +
 +
opc = menu("1. Sumatori", "2. Potència", "3. Suma Digital", "4. MCD", "5. Suma Harmònica", "6. Existeix Dígit")
 +
if opc=="1":
 +
  digits = int(input("Introdueix el número de enters a sumar: "))
 +
  print("Resultat suma dels %d primers números naturals: " %digits, sumatori(digits))
 +
elif opc=="2":
 +
  num = int(input("Introdueix un número: "))
 +
  pot = int(input("Introdueix la potència: "))
 +
  print("Resultat de %d elevat a %d: " %(num, pot), potencia(num, pot))
 +
if opc=="3":
 +
  num = int(input("Introdueix un número per sumar els seus dígits: "))
 +
  print("Resultat suma dels dels dígits del número %d: " %num, sumaDigital(num))
 +
if opc=="4":
 +
  num1 = int(input("Introdueix un número: "))
 +
  num2 = int(input("Introdueix un segon número: "))
 +
  print("MCD dels números %d i %d és: " %(num1, num2), mcd(num1,num2))
 +
if opc=="5":
 +
  num = int(input("Introdueix un número per fer la seva suma harmònica: "))
 +
  print("Resultat de la suma harmònica del número %d: " %num, sumaHarmonica(num))
 +
if opc=="6":
 +
  num = int(input("Introdueix un número: "))
 +
  digit = int(input("Introdueix un dígit: "))
 +
  print("Existeix el dígit %d en el número %d: " %(digit, num), existeixDigit(num,digit))
 +
</source>
 +
 +
1. Escriure una funció recursiva que donat un número N (N ≥ 0) passat com a paràmetre calculi la suma de tots els números enters fins a N inclòs.
 +
<source lang="python">
 +
def sumatori(n):
 +
    suma = 0;
 +
    if n > 0:
 +
      suma = n + sumatori(n - 1)
 +
    return suma
 +
</source>
 +
 +
2. Escriure una funció recursiva que calculi el resultat de X elevat a N amb N >0, sabent que X0 = 1.
 +
<source lang="python">
 +
def potencia(num, pot):
 +
    res = 1;
 +
    if pot > 0:
 +
      res = potencia(num, pot - 1) * num
 +
    return res
 +
</source>
 +
 +
3. Escriu una funció recursiva per calcular la suma digital d’un número natural. Per exemple, la suma digital de 18624 és: 4 + 2 + 6 + 8 + 1 = 21
 +
<source lang="python">
 +
def sumaDigital(n):
 +
    if n < 10:
 +
      suma = n
 +
    else:
 +
      suma = sumaDigital(n // 10)
 +
      suma = suma + n % 10
 +
    return suma
 +
</source>
 +
 +
4. Dissenyeu un algoritme recursiu que calculi el màxim comú divisor de dos enters positius, sabent que :
 +
<pre>
 +
    MCD( X, Y) = MCD (X-Y, Y) SI X > Y
 +
    MCD (X, Y-X) SI Y > X
 +
    X SI X = Y
 +
</pre>
 +
<source lang="python">
 +
def mcd(x, y):
 +
    if x==y:
 +
      return x
 +
    elif x > y:
 +
      return mcd(x - y, y)
 +
    else:
 +
      return mcd(x, y - x);   
 +
</source>
 +
   
 +
5. Fes la funció recursiva SumaHarmonica (n) que retorna la suma:
 +
<pre>
 +
    1 + 1/2 +1/3 + ... + 1/n
 +
</pre>
 +
<source lang="python">
 +
def sumaHarmonica(n):
 +
    suma=0.0
 +
    if n>0:
 +
      suma=sumaHarmonica(n-1)+1.0/n
 +
    return suma
 +
</source> 
 +
 
 +
6. Fes una funció recursiva booleana que donats un número i un dígit retorni si aquest dígit pertany al número. Per exemple:
 +
<pre>
 +
  existeix(1234,3) → true
 +
  existeix(1234,7) → false
 +
</pre>
 +
<source lang="python">
 +
def existeixDigit(numero, dig):
 +
    exist=False;
 +
    if numero > 0:
 +
      exist=(numero % 10 == dig) or existeixDigit(numero // 10, dig)
 +
    return exist;
 +
</source> 
 +
 +
7. Fes una funció que calculi el producte segons el mètode rus que diu que:
 +
<pre>
 +
    x*y = ((2*x) *(y/2)) SI y es parell
 +
    x*y =((2*x) *(y/2))+ x SI y és senar.
 +
 +
    Quan y val 1, el resultat és x.
 +
</pre>
 +
    public int producteRus(int x, int y) {
 +
        if (y == 1) {
 +
            return x;
 +
        } else if (y % 2 == 0) {
 +
            return producteRus(2 * x, y / 2);
 +
        } else {
 +
            return producteRus(2 * x, y / 2) + x;
 +
        }
 +
    }
 +
 +
 +
}
 +
8. Torres de Hanoi (amb N introduïda per l’usuari com a paràmetre). S’ha d’anar visualitzant la solució per pantalla.
 +
 +
9. Fes una funció recursiva que ompli un tauler n-goro. Un tauler n-goro és una matriu de n files i n+1 columnes que s'omple consecutivament en diagonal i quan ens sortim per una banda entrem per l'altra. L'últim element que s'omple serà l'extrem inferior dret.
 +
<pre>
 +
    Per exemple amb n=3
 +
 +
      1 10 7 4
 +
      5 2 11 8
 +
      9 6 3 12
 +
 +
    Amb n = 4
 +
 +
      1 17 13 9 5
 +
      6 2 18 14 10
 +
      11 7 3 19 15
 +
      16 12 8 4 20
 +
</pre>
 +
<!--
 +
Soluciones
 +
 +
https://foro.elhacker.net/ejercicios/ejercicios_recursivos_en_java_y_sus_soluciones-t231013.0.html
 +
-->

Revisió de 19:17, 23 març 2021

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

Quadrat màgic

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 n2 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):
   qm = assignaValor(qm,pos,valor)
   pos = calcularNovaPosicio(qm, dim, pos) 
imprimirQuadrat(qm)

Mastermind

El Mastermind és un joc que consisteix en, mitjançant pistes, deduir un codi numèric de n xifres ocult (en el nostre cas de quatre xifres i generat aleatòriament). Dinàmica del joc:

  • El programa generà aleatòriament un codi numèric de quatre xifres (codi a endevinar).
  • El jugador anirà proposant codis (intents) per tal de trobar el codi a endevinar.
  • L'objectiu es trobar el codi en el menor número d'intents. Es pot limitar el número d'intents (per ex. a 7).
  • Desprès de cada intent el programa donarà pistes que ajudin a deduir el codi:
  • Encerts: quants números s'han encertat i es troben en la posició correcta .
  • Coincidències: quants números s'han encertat però no es troben en la posició correcta.
  • Exemple:
  • codi: 7539
  • proposta: 2590
  • pistes: 1 encert i 1 coincidència.
  • El joc finalitzarà quan s'hagi trobat el codi numèric o s'hagin exhaurit els intents.
  • El programa permetrà tornar a jugar si així o vol el jugador.
  • Diagrama de flux
Diagrama flux "Mastermind"


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 permetrà tornar a jugar si així o vol el jugador.
  • Diagrama de flux
Diagrama flux "El Penjat"

3 en ratlla

El joc consisteix en posar 3 fitxes en línia en un tauler de 9 caselles abans que ho faci l'ordinador.

  • El jugador i l'ordinador alternen les jugades.
  • El jugador escollirà el símbol que vol (X o O) i es farà un sorteig de qui comença la partida
  • L'ordinador analitzarà la situació del tauler per cercar la millor jugada a fer.
  • La partida finalitzarà en el moment que un dels jugadors aconsegueixi fer 3 fitxes en linia o quan el tauler estigui omplert.
  • Cal informar del resultat de la partida: Guanya la persona, l'oridnador o hi ha hagut un empat.
  • El programa permetrà tornar a jugar si així o vol el jugador.


Recursivitat

Obtingut de «http://wikiserver.infomerce.es/index.php?title=ASIX-M3-UF2-Banc_de_Solucions&oldid=15406»