Domanda Mani di poker in python

Stato
Discussione chiusa ad ulteriori risposte.

danielescoti

Utente Bronze
8 Aprile 2016
26
10
0
38
sto cercando di scrivere un programma che prende come input due o piu mani (poker a 5 carte) e che restituisca la mano migliore.

sto seguendo i video di Audacity playlist "Design of computer programs"

ho un paio di problemi con il codice che vi lascio qui
Python:
def comparazioneMani(mani):
    return max(mani, key=valoreMano)
   
def test():
    scalaColore = [(6,"F"), (7,"F"), (8,"F"), (9,"F"), (10,"F")]
    quattroCopie = [(8,"C"), (8,"Q"), (8,"F"), (8,"P"), (7,"P")]
    fullHouse = [(4,"C"), (4,"Q"), (4,"F"), (3,"C"), (3,"Q")]
    doppiaCoppia  = [(4,"C"), (4,"Q"), (3,"F"), (3,"C"), (2,"Q")]
    quattroCopieValori = valoreCarta(quattroCopie)
    quattroCopieSemi = semeCarta(quattroCopie)
    doppiaCoppiaValori = valoreCarta(doppiaCoppia)
    doppiaCoppiaSemi = semeCarta(doppiaCoppia)
    assert tipoCarta(4, quattroCopieValori) == 8
    assert tipoCarta(3, quattroCopieValori) == None
    assert tipoCarta(2, quattroCopieValori) == None
    assert tipoCarta(1, quattroCopieValori) == 7
    assert doppiaCoppiaSemi == ['C','Q','F','C','Q']
    assert quattroCopieSemi == ['C','Q','F','P','P']
   
    #ERRORE
   
    ####################################################
    #                                                   #
    #assert doppiaCoppia(quattroCopieValori) == None   #
    #assert doppiaCoppia(doppiaCoppiaValori) == (4, 3) #
    #                                                   #
    ####################################################
   
   
    #Traceback (most recent call last):
  #File "untitled.py", line 106, in <module>
    #print(test())
  #File "untitled.py", line 26, in test
    #assert doppiaCoppia(quattroCopieValori) == None
#TypeError: 'list' object is not callable
   
   
    assert scala([9, 8, 7, 6, 5]) == True
    assert scala([9, 7, 7, 6, 5]) == False
    assert colore(scalaColore) == True
    assert colore(quattroCopie) == False
    assert valoreCarta(scalaColore) == [10, 9, 8, 7, 6]
    assert valoreCarta(quattroCopie) == [8, 8, 8, 8, 7]
    assert valoreCarta(fullHouse) == [4, 4, 4, 3, 3]
    assert comparazioneMani([scalaColore, quattroCopie, fullHouse]) == scalaColore
    assert comparazioneMani([quattroCopie, fullHouse]) == quattroCopie
    assert comparazioneMani([fullHouse, fullHouse]) == fullHouse
    assert valoreMano(scalaColore) == (8, 10)
    assert valoreMano(quattroCopie) == (7, 8, 7)
    assert valoreMano(fullHouse) == (6, 4, 3)
    return "test passato"

def tipoCarta(n, valori):
    for v in valori:
        if valori.count(v) == n: return v
    return None
   
def doppiaCoppia(valori):
    coppiaAlta = tipoCarta(2, valori)
    coppiaBassa = tipoCarta(2, list(reversed(valori)))
    if coppiaAlta and coppiaBassa != coppiaAlta:
        return (coppiaAlta, coppiaBassa)
    else:
        return None


def scala(valori):
    return ((max(valori)-min(valori) == 4) and (len(set(valori)) == 5))
   
def valoreMano(mano):
    valori = valoreCarta(mano)
    if scala(valori) and colore(mano):    #scala colore
        return (8, max(valori))
    elif tipoCarta(4, valori):    #quattro copie
        return (7, tipoCarta(4, valori), tipoCarta(1, valori))
    elif tipoCarta(3, valori) and tipoCarta(2, valori):    #full house
        return (6, tipoCarta(3, valori), tipoCarta(2, valori))
    elif colore(mano):    #colore                       
        return (5, valori)
    elif scala(mano):    #scala
        return (4, max(valori))
    elif tipoCarta(3, valori):    #tris
        return (3, tipoCarta(3, valori), valori)
    elif doppiaCoppia(valori):    #doppia coppia
        return (2, doppiaCoppia(valori), valori)
    elif valori(2, valori):    #coppia
        return (1, tipoCarta(2, valori), valori)
    else:    #carta alta
        return (0, valori)

def valoreCarta(carte):
    valori = [v for v,s in carte]
    valori.sort(reverse=True)
    return valori

def semeCarta(carte):
    semiC = [s for v,s in carte]
    return semiC

def colore(mano):
    semi = [s for v,s in mano]
    return len(set(semi)) == 1

print(test())

#ERRORE

###############################################################################################################
#                                                                                                             #
# comparazioneMani([[(3,"P"),(4,"Q"),(4,"F"),(8,"F"),(12,"P")], [(4,"P"),(8,"Q"),(4,"F"),(8,"F"),(12,"P")]])  #
#                                                                                                              #
###############################################################################################################


#Traceback (most recent call last):
  #File "untitled.py", line 112, in <module>
    #comparazioneMani([[(3,"P"),(4,"Q"),(4,"F"),(8,"F"),(12,"P")], [(4,"P"),(8,"Q"),(4,"F"),(8,"F"),(12,"P")]])
  #File "untitled.py", line 4, in comparazioneMani
    #return max(mani, key=valoreMano)
  #File "untitled.py", line 82, in valoreMano
    #elif scala(mano):    #scala
  #File "untitled.py", line 70, in scala
    #return ((max(valori)-min(valori) == 4) and (len(set(valori)) == 5))
#TypeError: unsupported operand type(s) for -: 'tuple' and 'tuple'

Ho evidenziato nei commenti le parti che mi danno problemi

qualcuno ha qualche idea su come migliorare il codice?

è uno dei primi post che faccio, plz spare my soul admins/mods
 
Caio, tralasciando le cose stilistiche per la leggibilità da migliorare ci sono diversi errori nella funzione valoreMano di seguito con commenti:

Python:
def valoreMano(mano):
    valori = valoreCarta(mano)
    if scala(valori) and colore(mano):  # scala colore
        return (8, max(valori))
    elif tipoCarta(4, valori):  # quattro copie
        return (7, tipoCarta(4, valori), tipoCarta(1, valori))
    elif tipoCarta(3, valori) and tipoCarta(2, valori):  # full house
        return (6, tipoCarta(3, valori), tipoCarta(2, valori))
    elif colore(mano):  # colore
        return (5, valori)
    elif scala(mano):  # scala    # --> Qui penso ci vada valori, se passi mano passi una tupla e scala() va in errore
        return (4, max(valori))
    elif tipoCarta(3, valori):  # tris
        return (3, tipoCarta(3, valori), valori)
    elif doppiaCoppia(valori):  # doppia coppia
        return (2, doppiaCoppia(valori), valori)
    elif valori(2, valori):  # coppia # -->Qui penso serva tipoCarta() non valori(), valori è una lista, non può essere chimata
        return (1, tipoCarta(2, valori), valori)
    else:  # carta alta
        return (0, valori)
Fammi sapere.
 
grazie mille!
avevi ragione
l'errore sulla # coppia era una svista anche perché valori non è una funzione ma una lista.
Qualche idea su come risolvere i problemi in test()?
 
scusa non avevo visto...
Ma stesso errore, doppia coppia è una variabile popolata con una lista nella funzione test(), cambia nome della variabile
 
Stato
Discussione chiusa ad ulteriori risposte.