Mes: julio 2012 Página 2 de 6

   1: class Punto:

   2:     def __init__(self, x=0, y=0):

   3:         self.x = x

   4:         self.y = y

   5:         def __str__(self):

   6:         return '(' + str(self.x) + ', ' + str(self.y) + ')'

   7:     def __add__(self, otro):

   8:         return Punto(self.x + otro.x, self.y + otro.y)

   9:     def __sub__(self, otro):

  10:         return Punto(self.x - otro.x, self.y - otro.y)

  11:     def __mul__(self, otro):

  12:         return self.x * otro.x + self.y * otro.y

  13:     def __rmul__(self, otro):

  14:         return Punto(otro * self.x, otro * self.y)

  15:     def reverse(self):

  16:         self.x, self.y = self.y, self.x

  17:     def delDerechoYDelReves(derecho):

  18:         from copy import copy

  19:         reves = copy(derecho)

  20:         reves.reverse()

  21:         print str(derecho) + str(reves)

   1: class Hora:

   2:     def __init__(self, horas=0, minutos=0, segundos=0):

   3:         self.horas = horas

   4:         self.minutos = minutos

   5:         self.segundos = segundos

   6:     def __str__(self):

   7:         return str(self.horas) + ":" + str(self.minutos) 

   8:         + ":" + str(self.segundos)

   9:     def convierteASegundos(self):

  10:         minutos = self.horas * 60 + self.minutos

  11:         segundos = self.minutos * 60 + self.segundos

  12:         return segundos

  13:     def incrementa(self, segs):

  14:         segs = segs + self.segundos

  15:         self.horas = self.horas + segs/3600

  16:         segs = segs % 3600

  17:         self.minutos = self.minutos + segs/60

  18:         segs = segs % 60

  19:         self.segundos = segs

  20:     def haceHora(segs):

  21:         hora = Hora()

  22:         hora.horas = segs/3600

  23:         segs = segs - hora.horas * 3600

  24:         hora.minutos = segs/60

  25:         segs = segs - hora.minutos * 60

  26:         hora.segundos = segs

  27:         return hora

   1: import random

   2: class Carta:

   3:     listaDePalos = ["Tr¶eboles", "Diamantes", "Corazones",

   4:     "Picas"]

   5:     listaDeValores = ["nada", "As", "2", "3", "4", "5", "6", "7",

   6:     "8", "9", "10", "Sota", "Reina", "Rey"]

   7:     

   8:     def __init__(self, palo=0, valor=0):

   9:         self.palo = palo

  10:         self.valor = valor

  11:     def __str__(self):

  12:         return (self.listaDeValores[self.valor] + " de " +

  13:         self.listaDePalos[self.palo])

  14:     def __cmp__(self, otro):

  15:         # controlar el palo

  16:         if self.palo > otro.palo: return 1

  17:         if self.palo < otro.palo: return -1

  18:         # si son del mismo palo, controlar el valor

  19:         if self.valor > otro.valor: return 1

  20:         if self.valor < otro.valor: return -1

  21:         # los valores son iguales, es un empate

  22:         return 0

  23:  

  24: class Mazo:

  25:     def __init__(self):

  26:         self.cartas = []

  27:         for palo in range(4):

  28:             for valor in range(1, 14):

  29:                 self.cartas.append(Carta(palo, valor))

  30:  

  31:     def muestraMazo(self):

  32:         for carta in self.cartas:

  33:             print carta

  34:     def __str__(self):

  35:         s = ""

  36:         for i in range(len(self.cartas)):

  37:             s = s + " "*i + str(self.cartas[i]) + "n"

  38:             return s

  39:     def mezclar(self):

  40:         import random

  41:         nCartas = len(self.cartas)

  42:         for i in range(nCartas):

  43:         j = random.randrange(i, nCartas)

  44:         self.cartas[i], self.cartas[j] =

  45:         self.cartas[j], self.cartas[i]

  46:     def eliminaCarta(self, carta):

  47:         if carta in self.cartas:

  48:             self.cartas.remove(carta)

  49:             return 1

  50:         else: return 0

  51:     def darCarta(self):

  52:         return self.cartas.pop()

  53:     def estaVacio(self):

  54:         return (len(self.cartas) == 0)

  55:     def repartir(self, manos, nCartas=999):

  56:         nManos = len(manos)

  57:         for i in range(nCartas):

  58:         if self.estaVacio(): break # fin si se acaban las cartas

  59:             carta = self.darCarta() # da la carta superior

  60:             mano = manos[i % nManos] # a qui¶en le toca?

  61:             mano.agregaCarta(carta) # agrega la carta a la mano

  62:  

  63: class Mano(Mazo):

  64:     def __init__(self, nombre=""):

  65:         self.cartas = []

  66:         self.nombre = nombre

  67:     def agregaCarta(self,carta) :

  68:         self.cartas.append(carta)

  69:     def __str__(self):

  70:         s = "La mano de " + self.nombre

  71:         if self.estaVacio():

  72:             s = s + " est¶a vac¶³an"

  73:         else:

  74:             s = s + " contienen"

  75:     return s + Mazo.__str__(self)

  76:  

  77: class JuegoDeCartas:

  78:     def __init__(self):

  79:         self.mazo = Mazo()

  80:         self.mazo.mezclar()

  81:  

  82: class ManoDeLaMona(Mano):

  83:     def eliminaCoincidencias(self):

  84:         cant = 0

  85:         cartasOriginales = self.cartas[:]

  86:         for carta in cartasOriginales:

  87:             empareja = Carta(3 - carta.palo, carta.valor)

  88:             if empareja in self.cartas:

  89:             self.cartas.remove(carta)

  90:             self.cartas.remove(empareja)

  91:             print "Mano %s: %s con %s" % (self.nombre,carta,empareja)

  92:             cant = cant + 1

  93:             return cant

  94:  

  95: class JuegoDeLaMona(JuegoDeCartas):

  96:     def jugar(self, nombres):

  97:     # quitamos la Reina de Tr¶eboles

  98:     self.mazo.eliminaCarta(Carta(0,12))

  99:         # construimos una mano para cada jugador

 100:     self.manos = []

 101:     for nombre in nombres :

 102:         self.manos.append(ManoDeLaMona(nombre))

 103:         # repartimos los naipes

 104:         self.mazo.repartir(self.manos)

 105:         print "----- Se han repartido las cartas."

 106:         self.muestraManos()

 107:         # eliminamos las coincidencias iniciales

 108:         emparejadas = self.eliminaTodasLasCoincidencias()

 109:         print "----- Coincidencias eliminadas, el juego comienza."

 110:         self.muestraManos()

 111:         # se juega hasta que se han descartado las 50 cartas

 112:         turno = 0

 113:         cantManos = len(self.manos)

 114:         while emparejadas < 25:

 115:         emparejadas = emparejadas + self.jugarUnTurno(turno)

 116:             turno = (turno + 1) % cantManos

 117:             print "----- El juego termin¶o."

 118:             self.muestraManos()

 119:     def eliminaTodasLasCoincidencias(self):

 120:     cant = 0

 121:     for mano in self.manos:

 122:         cant = cant + mano.eliminaCoincidencias()

 123:         return cant

 124:     def jugarUnTurno(self, i):

 125:     if self.manos[i].estaVacio():

 126:         return 0

 127:         vecino = self.encuentraVecino(i)

 128:     cartaElegida = self.manos[vecino].darCarta()

 129:     self.manos[i].agregaCarta(cartaElegida)

 130:     print "Mano", self.manos[i].nombre, "eligi¶o", cartaElegida

 131:     cant = self.manos[i].eliminaCoincidencias()

 132:     self.manos[i].mezclar()

 133:     return cant

 134:  

 135:     def encuentraVecino(self, i):

 136:     cantManos = len(self.manos)

 137:     for proximo in range(1,cantManos):

 138:         vecino = (i + proximo) % cantManos

 139:         if not self.manos[vecino].estaVacio():

 140:             return vecino

 141:     def muestraManos(self) :

 142:     for mano in self.manos :

 143:         print mano

   1: def imprimeLista(nodo):

   2:     while nodo:

   3:         print nodo,

   4:         nodo = nodo.siguiente

   5:         print

   6: def imprimeAlReves(lista):

   7:     if lista == None: return

   8:     cabeza = lista

   9:     cola = lista.siguiente

  10:     imprimeAlReves(cola)

  11:     print cabeza,

  12: def imprimeAlRevesBonito(lista) :

  13:     print "[",

  14:     if lista != None :

  15:         cabeza = lista

  16:         cola = lista.siguiente

  17:  

  18: imprimeAlReves(cola)

  19: print cabeza,

  20: print "]",

  21:  

  22: def eliminaSegundo(lista):

  23:     if lista == None: return

  24:         primero = lista

  25:         segundo = lista.siguiente

  26:         primero.siguiente = segundo.siguiente

  27:         segundo.siguiente = None

  28:         return segundo

  29:  

  30: class Nodo:

  31:     def __init__(self, carga=None, siguiente=None):

  32:         self.carga = carga

  33:         self.siguiente = siguiente

  34:  

  35:     def __str__(self):

  36:         return str(self.carga)

  37:  

  38:     def imprimeAlReves(self):

  39:         if self.siguiente != None:

  40:             cola = self.siguiente

  41:             cola.imprimeAlReves()

  42:             print self.carga,

  43:  

  44: class ListaEnlazada :

  45:     def __init__(self) :

  46:         self.longitud = 0

  47:         self.cabeza = None

  48:     def imprimeAlReves(self):

  49:         print "[",

  50:         if self.cabeza != None:

  51:         self.cabeza.imprimeAlReves()

  52:         print "]",

  53:     def agregaPrimero(self, carga):

  54:         nodo = Nodo(carga)

  55:         nodo.siguiente = self.cabeza

  56:         self.cabeza = nodo

  57:         self.longitud = self.longitud + 1 

   1: class Pila : # implem. con listas de Python

   2:     def __init__(self) :

   3:         self.elementos = []

   4:     def push(self, elemento) :

   5:         self.elementos.append(elemento)

   6:     def pop(self) :

   7:         return self.elementos.pop()

   8:     def isEmpty(self) :

   9:         return (self.elementos == [])

  10:     def evalPostfijo(expr):

  11:         import re

  12:         listaTokens = re.split("([^0-9])", expr)

  13:         pila = Pila()

  14:         for token in listaTokens:

  15:         if token == '' or token == ' ':

  16:             continue

  17:         if token == '+':

  18:             suma = pila.pop() + pila.pop()

  19:             pila.push(suma)

  20:             elif token == '*':

  21:             producto = pila.pop() * pila.pop()

  22:             pila.push(producto)

  23:         else:

  24:             pila.push(int(token))

  25:         return pila.pop()

   1: class Cola :

   2:     def __init__(self) :

   3:         self.longitud = 0

   4:         self.cabeza = None

   5:  

   6:     def vacia(self) :

   7:         return (self.longitud == 0)

   8:  

   9:     def inserta(self, carga) :

  10:         nodo = Nodo(carga)

  11:         nodo.siguiente = None

  12:             if self.cabeza == None :

  13:             # Si la lista esta vac³a nuestro nuevo nodo es el primero

  14:             self.cabeza = nodo

  15:         

  16:             else :

  17:             # Encuentra el ultimo nodo de la lista

  18:             ultimo = self.cabeza

  19:             while ultimo.siguiente : ultimo = ultimo.siguiente

  20:                 # Añada el nuevo nodo

  21:                 ultimo.siguiente = nodo

  22:                 self.longitud = self.longitud + 1

  23:  

  24:     def quita(self) :

  25:         carga = self.cabeza.carga

  26:         self.cabeza = self.cabeza.next

  27:         self.longitud = self.longitud - 1

  28:         return carga

  29: class ColaMejorada :

  30:     def __init__(self) :

  31:     self.longitud = 0

  32:     self.cabeza = None

  33:     self.ultimo = None

  34:  

  35:  

  36:     def vacia(self) :

  37:         return (self.longitud == 0)

  38:  

  39:     def inserta(self, carga) :

  40:         nodo = Nodo(carga)

  41:         nodo.siguiente = None

  42:             if self.longitud == 0 :

  43:             # Si la lista esta vac³a nuestro nuevo nodo es el primero

  44:             self.cabeza = self.ultimo = nodo

  45:             

  46:             else :

  47:                 # Encuentra el ultimo nodo de la lista

  48:                 ultimo = self.ultimo

  49:                 # Añade nuestro nodo nuevo

  50:                 ultimo.siguiente = nodo

  51:                 self.ultimo = nodo

  52:                 self.longitud = self.longitud + 1

  53:     def quita(self) :

  54:         carga = self.cabeza.carga

  55:         self.cabeza = self.cabeza.siguiente

  56:         self.longitud = self.longitud - 1

  57:             if self.longitud == 0 : self.ultimo = None

  58:                 return carga

  59: class ColaPriorizada :

  60:     def __init__(self) :

  61:         self.elementos = []

  62:     def vacia(self) :

  63:         return self.elementos == []

  64:     def inserta(self, elemento) :

  65:         self.elementos.append(elemento)

  66:     def quita(self) :

  67:         maxi = 0

  68:         for i in range(1,len(self.elementos)) :

  69:         if self.elementos[i] > self.elementos[maxi] :

  70:             maxi = i

  71:             elemento = self.elementos[maxi]

  72:             self.elementos[maxi:maxi+1] = []

  73:             return elemento

  74: class Golfista :

  75:     def __init__(self, nombre, puntos) :

  76:         self.nombre = nombre

  77:         self.puntos = puntos

  78:     def __str__(self) :

  79:         return "%-15s: %d" % (self.nombre, self.puntos)

  80:     def __cmp__(self, otro) :

  81:         if self.puntos < otro.puntos : return 1 # menos es mas

  82:         if self.puntos > otro.puntos : return -1

  83:             return 0

   1: class Arbol :

   2: def __init__(self, carga, izquierda=None, derecha=None) :

   3:     self.carga = carga

   4:     self.izquierda = izquierda

   5:     self.derecha = derecha

   6:  

   7: def __str__(self) :

   8:     return str(self.carga)

   9:  

  10: def tomaCarga(self): return self.carga

  11: def tomaIzquierda(self): return self.izquierda

  12: def tomaDerecha(self): return self.derecha

  13: def ajustaCarga(self, carga): self.carga = carga

  14: def ajustaIzquierda (self, izquierda): self.left = izquierda

  15: def ajustaDerecha(self, derecha): self.derecha = derecha

  16:  

  17: def total(arbol) :

  18:     if arbol == None : return 0

  19:     return total(arbol.izquierda) + total(arbol.derecha) + arbol.carga

  20:  

  21: def imprimeArbol(arbol):

  22:     if arbol == None: return

  23:     print arbol.carga,

  24:     imprimeArbol(arbol.izquierda)

  25:     imprimeArbol(arbol.derecha)

  26:  

  27: def imprimeArbolPosfijo(arbol):

  28:     if arbol == None: return

  29:     imprimeArbolPosfijo(arbol.izquierda)

  30:     imprimeArbolPosfijo(arbol.derecha)

  31:     print arbol.carga,

  32:  

  33: def imprimeArbolInfijo(arbol):

  34:     if arbol == None: return

  35:     imprimeArbolInfijo(arbol.izquierda)

  36:     print arbol.carga,

  37:     imprimeArbolInfijo(arbol.derecha)

  38:  

  39: def imprimeArbolSangrado(arbol, nivel=0):

  40:     if arbol == None: return

  41:     imprimeArbolSangrado(arbol.derecha, nivel+1)

  42:     print ' '*nivel + str(arbol.carga)

  43:     imprimeArbolSangrado(arbol.izquierda, nivel+1)

   1: def tomaToken(listaToken, esperado):

   2:     if listaToken[0] == esperado:

   3:         listaToken[0:1] = [] # quita el token

   4:         return 1

   5:     else:

   6:         return 0

   7: def obtieneProducto(listaToken) :

   8:  

   9: a = obtieneNumero(listaToken)

  10:     if tomaToken(listaToken, '*') :

  11:         b = obtieneProducto(listaToken)

  12:         return Arbol('*', a, b)

  13:     else :

  14:         return a

  15:  

  16: def obtieneSuma(listaToken) :

  17: a = obtieneProducto(listaToken)

  18:     if tomaToken(listaToken, '+') :

  19:         b = obtieneSuma(listaToken)

  20:         return Arbol('+', a, b)

  21:     else :

  22:         return a

  23:  

  24: def obtieneNumero(listaToken):

  25:     

  26:     if tomaToken(listaToken, '(') :

  27:         x = obtieneSuma(listaToken) # obtiene subexpresion

  28:         tomaToken(listaToken, ')') # se come el cierre de parentesis

  29:         return x

  30:     else :

  31:         x = listaToken[0]

  32:  

  33:     if type(x) != type(0) : return None

  34:         listaToken[0:1] = [] # quita el token

  35:         return Arbol(x, None, None) # devuelve una hoja sin el numero

   1: def animal():

   2:  

   3: # empezar con un nodo suelto

   4: raiz = Arbol("pajaro")

   5: # bucle hasta que el usuario salga

   6: while 1:

   7: print

   8:  

   9:     if not si("Estas pensando en un animal? "): break

  10:         # recorrer el arbol

  11:         arbol = raiz

  12:         while arbol.tomaIzquierda() != None:

  13:         indicador = arbol.tomaCarga() + "? "

  14:     

  15:     if si(indicador):

  16:         arbol = arbol.tomaDerecha()

  17:     else:

  18:         arbol = arbol.tomaIzquierda()

  19:     

  20: # intentar adivinar

  21: adivina = arbol.tomaCarga()

  22: indicador = "Es un " + adivina + "? "

  23:  

  24:     if si(indicador):

  25:         print "^A<Soy el mas grande!"

  26:         continue

  27:  

  28: # obtener informacion nueva

  29: indicador = "Como se llama el animal? "

  30: animal = raw_input(indicador)

  31: indicador = "Que pregunta distinguir³a a un %s de un %s? "

  32: pregunta = raw_input(indicador % (animal,adivina))

  33:  

  34: # a~nadir informacion nueva al arbol

  35: arbol.ponCarga(pregunta)

  36: indicador = "Si el animal fuera un %s, cual ser³a la respuesta? "

  37:     if si(indicador % animal):

  38:         arbol.ponIzquierda(Arbol(adivina))

  39:     arbol.ponDerecha(Arbol(animal))

  40:     

  41:     else:

  42:         arbol.ponIzquierda(Arbol(animal))

  43:         arbol.ponDerecha(Arbol(adivina))

  44:     

  45:     def si(preg):

  46:         from string import lower

  47:         resp = lower(raw_input(preg))

  48:         return (resp[0:1] == 's')

   1: class Fraccion:

   2:     def __init__(self, numerador, denominador=1):

   3:     m = mcd (numerador, denominador)

   4:     self.numerador = numerador / m

   5:     self.denominador = denominador / m

   6:     def __mul__(self, otro):

   7:     

   8:         if type(otro) == type(5):

   9:         otro = Fraccion(otro)

  10:         return Fraccion(self.numerador * otro.numerador,

  11:    

  12:  

  13:      self.denominador * otro.denominador)

  14:     __rmul__ = __mul__

  15:     def __add__(self, otro):

  16:     

  17:     if type(otro) == type(5):

  18:         otro = Fraccion(otro)

  19:         return Fraccion(self.numerador * otro.denominador +

  20:     

  21:     self.denominador * otro.numerador,

  22:     self.denominador * otro.denominador)

  23:     __radd__ = __add__

  24:     def __cmp__(self, otro):

  25:     if type(otro) == type(5):

  26:         otro = Fraccion(otro)

  27:         dif = (self.numerador * otro.denominador -

  28:         otro.numerador * self.denominador)

  29:         return dif

  30:  

  31:     def __repr__(self):

  32:     return self.__str__()

  33:     def __str__(self):

  34:     return "%d/%d" % (self.numerador, self.denominador)

  35:  

  36:     def mcd(m,n):

  37:         "devuelve el maximo comun denominador de dos enteros"

  38:     if m % n == 0:

  39:         return n

  40:     else:

  41:     return mcd(n,m%n)