def sortearKino(L, numerosSorteados = None, listaGanadores = None):
if numerosSorteados == None:
numerosSorteados = numerosGanadores()
if vacia(L):
if listaGanadores == None:
print ("No hay ganadores")
return
else:
imprimirLista(listaGanadores)
return
assert type(L) == lista
assert type(cabeza(L)) == Kino
n = numerosIguales(numerosSorteados, cabeza(L).numeros)
if n == 14:
listaGanadores = lista("Premio 1 " + cabeza(L).Comprador, listaGanadores)
return sortearKino(cola(L),numerosSorteados, listaGanadores)
elif n == 13:
listaGanadores = lista("Premio 2 " + cabeza(L).Comprador, listaGanadores)
return sortearKino(cola(L),numerosSorteados,listaGanadores)
elif n == 12:
listaGanadores = lista("Premio 3 " + cabeza(L).Comprador, listaGanadores)
return sortearKino(cola(L),numerosSorteados,listaGanadores)
elif n == 11:
listaGanadores = lista("Premio 4 " + cabeza(L).Comprador, listaGanadores)
return sortearKino(cola(L),numerosSorteados,listaGanadores)
elif n == 10:
listaGanadores = lista("Premio 5 " + cabeza(L).Comprador, listaGanadores)
return sortearKino(cola(L),numerosSorteados, listaGanadores)
return sortearKino(cola(L),numerosSorteados,listaGanadores)
def los4MasSorteados(L):
mayor = fold(mayorNum, 0, L)
rango_ = rango(mayor)
# 1er mas sorteado
frecList = mapa(lambda x: contar(L, x), rango_)
mayorFrec = fold(mayorNum, 0, frecList)
i1 = buscar(mayorFrec, frecList)
n1 = indice(i1, rango_)
# 2o mas sorteado
frecList2 = primerMayorTo0(frecList)
mayorFrec2 = fold(mayorNum, 0, frecList2)
i2 = buscar(mayorFrec2, frecList2)
n2 = indice(i2, rango_)
# 3o mas sorteado
frecList3 = primerMayorTo0(frecList2)
mayorFrec3 = fold(mayorNum, 0, frecList3)
i3 = buscar(mayorFrec3, frecList3)
n3 = indice(i3, rango_)
# 4o mas sorteado
frecList4 = primerMayorTo0(frecList3)
mayorFrec4 = fold(mayorNum, 0, frecList4)
i4 = buscar(mayorFrec4, frecList4)
n4 = indice(i4, rango_)
return lista(n1, lista(n2, lista(n3, lista(n4, listaVacia))))
def ancestros(P):
assert P == None or Type(P) == persona
if P == None: return None
if P.padre == None:
L1 = None
else:
L1 = lista(P.padre, ancestros(P.padre))
if P.madre == None:
L2 = None
else:
L2 = lista(P.madre, ancestros(P.madre))
return juntar(L1, L2)
def actualizar(p, lreg):
if lreg == None:
newreg = registro(p, 1)
return lista(newreg, None)
else:
unregistro = cabeza(lreg)
if p == unregistro.palabra:
newreg = registro(p, unregistro.frecuencia + 1)
nlista = lista(newreg, cola(lreg))
return nlista
else: # si p no esta en lreg
nlista = lista(unregistro, actualizar(p, cola(lreg)))
return nlista
def filtro(L, f, x): #0.5 ptos
if L == None: return None #0.1
v = cabeza(L)
L = filtro(cola(L), f, x) #0.1
if f(v, x):
return lista(v, L) #0.2
return L #0.1
def creciente(L, new=listaVacia):
if L == listaVacia:
return new
mayor = fold(mayorNum, 0, L)
rep = contar(L, mayor)
filtrada = filtro(lambda x: x != mayor, L)
return creciente(filtrada, juntar(lista(mayor, listaVacia), new))
def aLista(A):
assert esAB(A)
if A == None: return
a = aLista(A.izq)
c = lista(A.valor, None)
b = aLista(A.der)
return juntar(a, juntar(c, b))
def evaluarLista(p, listax):
if listax == None:
return None
else:
x = cabeza(listax)
pEvaluado = evaluar(p, x)
return lista(pEvaluado, evaluarLista(p, cola(listax)))
def inv(L,l=None):
assert esLista(L)
if L==None:
return l
else:
l=lista(cabeza(L),l)
return inv(cola(L),l)
def filtro(operador, unaLista):
if vacia(unaLista):
return listaVacia
else:
if operador(cabeza(unaLista)):
return lista(cabeza(unaLista), filtro(operador, cola(unaLista)))
else:
return filtro(operador, cola(unaLista))
def filtro(L, comparacion, x):
assert esLista(L)
if L == None: return None
if comparacion(cabeza(L), x):
return lista(cabeza(L), filtro(cola(L), comparacion, x))
else:
return filtro(cola(L), comparacion, x)
def agregar(abr, sig, agenda):
assert agenda == None or type(agenda) == lista
if agenda == None:
return lista(registro(abr, sig), None)
#caso no es vacia la lista
reg = cabeza(agenda)
def eliminar(self,dato):
cadena = lista()
self._eliminar(self.raiz, dato, cadena)
cadena.eliminar(dato)
self.raiz = None
dato = cadena.getHead()
while dato != None:
self.agregar(dato.nombre,dato.apellido,dato.telefono,dato.mail)
dato = dato.getsiguiente()
def numerosGanadores(listaParcial = None, cont1 = 0):
if cont1 == 14:
assert esNumerosDeKino(listaParcial)
return listaParcial
enteroAleatorio = random.randint(1,25)
if xEstaEnL(enteroAleatorio,listaParcial):
return numerosGanadores(listaParcial, cont1)
else:
return numerosGanadores(lista(enteroAleatorio,listaParcial),cont1 + 1)
def resta(x,y,l=None):
assert esConjunto(x)
assert esConjunto(y)
if x==None: return l
if pertenece(cabeza(x),y):
return resta(cola(x),y,l)
else:
l=lista(cabeza(x),l)
return resta(cola(x),y,l)
def union(x,y):
assert esConjunto(x)
assert esConjunto(y)
if x==None: return y
if pertenece(cabeza(x),y):
return union(cola(x),y)
else:
y=lista(cabeza(x),y)
return union(cola(x),y)
def pares(L,l=None):
assert esLista(L)
if L==None:
return l
else:
if cabeza(L)%2==0:
l=lista(cabeza(L),l)
return pares(cola(L),l)
else:
return pares(cola(L),l)
def abbAlista(A):
assert esABB(A)
if A == None:
return
else:
l1 = abbAlista(A.izq)
valor = lista(A.valor,listaVacia)
l2 = abbAlista(A.der)
union_valor = unionListas(valor,l2)
return unionListas(l1,union_valor)
def listaPrimos(N, impar=3):
#caso base: 0.3 ptos
if N == 0: return None
#caso primo: 0.7 ptos
if esPrimo(impar): #0.2
#print 'lista primos=',lista(impar,listaPrimos(N-1,impar+2))
return lista(impar, listaPrimos(N - 1, impar + 2)) #0.5
#caso no primo: 0.3 ptos
else: #opcional
return listaPrimos(N, impar + 2)
def librosConPalabra(palabra, bib):
if bib == None:
return None #0.2
L1 = librosConPalabra(palabra, bib.izq) #0.4
L2 = librosConPalabra(palabra, bib.der) #0.4
libro = bib.valor #0.2
if palabra in libro.titulo: #0.3
return concatenar(L1, lista(libro, L2)) #0.5
else:
return concatenar(L1, L2)
def seleccionar(L,puntajeMinimo):
assert esLista(L)
if L==None:
return
p=cabeza(L)
m=lista(10,lista(20,lista(10,lista(45,lista(15,None)))))
if sumaproductos(p.puntajes,m)>puntajeMinimo:
return lista(p.run,lista(seleccionar(cola(L),puntajeMinimo)))
return seleccionar(cola(L),puntajeMinimo)
def listaSexo(A, sexo):
#caso base: 0.2 ptos
if A == None:
return None
#listas de arboles iq y der: 0.6
L1 = listaSexo(A.izq, sexo) #0.3
L2 = listaSexo(A.der, sexo) #0.3
#seleccionar por sexo: 1.0 ptos
if A.valor.sexo == sexo: #0.5
L2 = lista(A.valor.nombre, L2) #0.5
#concatenar listas: 0.5 ptos
return juntar(L1, L2)
def toqueyfama(I):
print I
if I == listaVacia:
x = random.randint(1000, 9999)
print 'Creo que es el ' + str(x)
f = raw_input('Cuantas famas?')
t = raw_input('Cuantos toques?')
if int(f) == 4:
print('Lo descubri!')
else:
I = lista(Jugada(x, int(t), int(f)), I)
return toqueyfama(I)
else:
print "lista no vacia=", I
n = candidatoFinal(I)
print 'Creo que es el ', n
f = raw_input('Cuantas famas?')
t = raw_input('Cuantos toques?')
if int(f) == 4:
print('Lo descubri!')
else:
I = lista(Jugada(n, int(t), int(f)), I)
return toqueyfama(I)
def get_item_lista():
item = lista()
print("Elegiste: ")
print("Autor: ",item[0],", Lenguaje: ",item[1],", País:",item[2])
autor = item[0]
if autor == 'Larry Wall':
autor = autor +", \n'Los verdaderos programadores pueden escribir código ensamblador en cualquier lenguaje.'"
elif autor == 'James Gosling':
autor = autor +" \n'La imitación es la forma más sincera de adulación, muchas gracias.'"
else:
if autor == "Guido van Rossum":
autor = autor +" \n'Python es mejor que cualquier otro lenguaje.'"
else:
autor = autor +" \n'Hola.'"
InfoMessage("Elegiste: \nAutor: "+autor+"\nLenguaje: "+item[1]+"\nPaís:"+item[2],width=250,height=140,title="Python for Beginners")
def mapa(funcion, L):
assert esLista(L)
if L == None:
return None
else:
return lista(funcion(cabeza(L)), mapa(funcion, cola(L)))
#mapa: (any->any) lista(any) -> lista(any)
#lista aplicando funcion a valores de L
#ej: mapa(f,lista(5,lista(4,None))) -> lista(f(5),lista(f(4),None))
def mapa(funcion, L):
assert esLista(L)
if L == None:
return None
else:
return lista(funcion(cabeza(L)), mapa(funcion, cola(L)))
assert mapa(lambda x: 5 * x,
lista(5, lista(4, None))) == lista(25, lista(20, None))
#esFraccion: fraccion->bool
#True si es una fraccion valida
#ej: esFraccion(fraccion(1,2))->True
#ej: esFraccion(fraccion(1,0))->False
def esFraccion(x):
return type(x)==fraccion \
and type(x.numerador)==int \
and type(x.denominador)==int \
and x.denominador!=0
assert esFraccion(fraccion(1, 2))
assert not esFraccion(fraccion(1, 0))
# filtro : (Y X -> bool) lista(X) Y -> lista(X)
# devuelve lista con todos los valores donde operador devuelve True
def filtro(funcion, unaLista, n):
if vacia(unaLista):
return listaVacia
else:
if (funcion(cabeza(unaLista), n)):
return crearLista(cabeza(unaLista),
filtro(funcion, cola(unaLista), n))
else:
return filtro(funcion, cola(unaLista), n)
# Tests
valores = lista(6, lista(4, lista(8, listaVacia)))
assert filtro(lambda x, y: x < y, valores, 5) == lista(4, listaVacia)
# mapa : (X -> Y) lista(X) -> lista(Y)
# devuelve lista con funcion aplicada a todos sus elementos
def mapa(f, unaLista):
if vacia(unaLista):
return listaVacia
else:
return crearLista(f(cabeza(unaLista)), mapa(f, cola(unaLista)))
# Tests
valores = lista(1, lista(2, lista(3, lista(4, listaVacia))))
assert mapa(lambda x: 10*x, valores) == \
estructura.crear("persona","nombre nacimiento hijos")
```
"""
from lista import *
#persona:nombre(str) nacimiento(int) hijos(lista(persona))
estructura.crear("persona","nombre nacimiento hijos")
#nietos
gustavo=persona("gustavo",1996,None)
#padres
andres=persona("andres",1950, None)
david=persona("david",1955,None)
eva=persona("eva",1965,lista(gustavo,None))
federico=persona("federico",1966,lista(gustavo,None))
#abuelos
hijosCarlosBeatriz=lista(andres,lista(david,lista(eva,None)))
carlos=persona("carlos",1926,hijosCarlosBeatriz)
beatriz=persona("beatriz",1926,hijosCarlosBeatriz)
#esDescendiente: persona persona -> bool
#True si persona x es descendiente de persona P
#ej: esDescendiente(gustavo,carlos)->True
def esDescendiente(x,P):
if P==None:
return False
if P==x:
return True
def juntar(L1, L2):
assert esLista(L1) and esLista(L2)
if L1 == None: return L2
return lista(cabeza(L1), juntar(cola(L1), L2))
#primera generacion ("abuelos")
carlos = persona("carlos", 1926, None, None, None)
beatriz = persona("beatriz", 1926, None, None, None)
#segunda generacion ("hijos")
andres = persona("andres", 1950, carlos, beatriz, None)
david = persona("david", 1955, carlos, beatriz, None)
eva = persona("eva", 1965, carlos, beatriz, None)
federico = persona("federico", 1966, None, None, None)
#tercera generacion ("nietos")
gustavo = persona("gustavo", 1996, federico, beatriz, None)
#completando con datos de padres, madres e hijos
eva.hijos = lista(gustavo, None)
federico.hijos = lista(gustavo, None)
carlos.hijos = lista(andres, lista(david, lista(eva, None)))
beatriz.hijos = lista(andres, lista(david, lista(eva, None)))
#esPadeDe: persona persona -> bool
#True si x es padre o madre de y
#ej esPadreDe(carlos,eva) -> True
#ej esPadreDe(beatriz,federico) -> False
def esPadreDe(x, y):
assert type(x) == persona and type(y) == persona
return x == y.padre or x == y.madre
assert esPadreDe(carlos, eva)
