def ordenados():
p = Pila()
p_aux = Pila()
aux = 0
elemento = input("Ingrese el elemento (-100 para no cargar mas): ")
int(elemento)
while (elemento != -100):
if pila_llena(p):
print("No hay mas espacio")
else:
if pila_vacia(p):
apilar(p, elemento)
else:
aux = desapilar(p)
while elemento < aux and not pila_vacia(p):
apilar(p_aux, aux)
aux = desapilar(p)
else:
if elemento < aux:
apilar(p, elemento)
apilar(p, aux)
else:
apilar(p, aux)
apilar(p, elemento)
if not pila_vacia(p_aux):
while not pila_vacia(p_aux):
apilar(p, desapilar(p_aux))
elemento = input("Ingrese el elemento (-100 para no cargar mas): ")
int(elemento)
barrido(p)
def buscar_personajes():
pila = Pila()
pila_auxiliar = Pila()
Leia_Organa = False
Boba_Fett = False
personajes_sw = [
'Leia Organa', 'Yoda', 'Palpatine', 'C-3po', 'Darth Maul',
'Darth Vader', 'Luke Skywalker', 'Chewbacca'
]
for i in range(0, 9):
star_w = random.choice(personajes_sw)
apilar(pila, star_w)
while not pila_vacia(pila):
m = desapilar(pila)
if m == 'Leia Organa':
apilar(pila_auxiliar, m)
Leia_Organa = True
if m == 'Boba Fett':
apilar(pila_auxiliar, m)
Boba_Fett = True
while not pila_vacia(pila_auxiliar):
apilar(pila, desapilar(pila_auxiliar))
if Leia_Organa == True:
print('Leia Organa existe en la pila de personajes')
if Boba_Fett == True:
print('Boba Fett existe en la pila de personajes')
def temperaturas(pila):
pila = Pila()
pila_aux = Pila()
t_max = cima(pila)
t_min = cima(pila)
t_med = 0
v_mayores = 0
v_menores = 0
print('Temperaturas registradas en el mes:')
barrido_pila(pila)
while not pila_vacia(pila):
dato = desapilar(pila)
t_med += dato
if dato < t_min:
t_min = dato
if dato > t_max:
t_max = dato
apilar(pila_aux, dato)
grado = tamanio_pila(pila_aux)
t_med = t_med / grado
while not pila_vacia(pila_aux):
dato = desapilar(pila_aux)
if dato >= t_med:
v_mayores += 1
else:
v_menores += 1
print('Temperatura minima:', t_min, '°')
print('Temperatura maxima :', t_max, '°')
print('El rango de temperatura media:', round(t_med, 2), '°')
print('Temperaturas mayores e iguales a la media:', v_mayores, '°')
print('Temperaturas menores a la media:', v_menores, '°')
def interseccion_personajes():
pila_5 = Pila()
pila_7 = Pila()
pila_aux = Pila()
e5 = [
'Luke Skywalker', 'Lando Calrissian', 'Yoda', 'Chewbacca',
'Emperador Palpatine', 'C3PO'
]
e7 = ['Rey', 'Finn', 'Luke Skywalker', 'Kylo Ren', 'Chewbacca', 'C3PO']
for i in range(0, len(e5)):
apilar(pila_5, e5[i])
apilar(pila_7, e7[i])
print('Episodio V: The empire strikes back')
barrido_pila(pila_5)
print('Episodio VII: The force awakens')
barrido_pila(pila_7)
while not pila_vacia(pila_5):
m = desapilar(pila_5)
while not pila_vacia(pila_7):
y = desapilar(pila_7)
if (m == y):
print('El personaje ' + str(m) +
' se encuentra en ambos episodios')
apilar(pila_aux, y)
while (not pila_vacia(pila_aux)):
y = desapilar(pila_aux)
apilar(pila_7, y)
def temperatura():
p = Pila()
p_aux = Pila()
sum = 0
c_encima = 0
c_debajo = 0
for i in range(0, 30):
apilar(p, random.randint(15, 27))
max = desapilar(p)
min = max
apilar(p, max)
while not pila_vacia(p):
aux = desapilar(p)
sum = sum + aux
if aux < min:
min = aux
if aux > max:
max = aux
apilar(p_aux, aux)
media = sum / 30
while not pila_vacia(p_aux):
aux = desapilar(p_aux)
if aux > media:
c_encima += 1
elif aux < media:
c_debajo += 1
apilar(p, aux)
print("Valor maximo de temperatura: ", max)
print("Valor minimo de temperatura: ", min)
print("Promedio del total de los valores: ", media)
print("Valores por encima de la media: ", c_encima)
print("Valores por debajo de la media: ", c_debajo)
print("Lista de los valores: ")
barrido(p)
def cartas():
p = Pila()
po = Pila()
pb = Pila()
pe = Pila()
pc = Pila()
palos = ['Oro', 'Basto', 'Copa', 'Espada']
while not pila_llena(p):
num = random.randint(1, 13)
palo = random.choice(palos)
apilar(p, [num, palo])
while not pila_vacia(p):
aux = desapilar(p)
if aux[1] == "Basto":
apilar(pb, aux)
if aux[1] == "Copa":
apilar(pc, aux)
if aux[1] == "Oro":
apilar(po, aux)
if aux[1] == "Espada":
apilar(pe, aux)
print("Mazo de basto")
barrido(pb)
print("Mazo de copa")
barrido(pc)
print("Mazo de oro")
barrido(po)
print("Mazo de espada")
barrido(pe)
pe = ordenar_pila(pe)
print("Mazo de espada ordenados")
barrido(pe)
def dijkstra(self, ver_origen, ver_destino):
"""Algoritmo de Dijkstra para hallar el camino mas corto."""
no_visitados = HeapMin()
camino = Pila()
aux = 0
while (aux < self.tamanio()):
vertice = self.inicio.obtener_elemento(ver_origen)
vertice_aux = self.inicio.obtener_elemento(aux)
vertice_aux['anterior'] = None
if (vertice_aux['info'] == vertice['info']):
no_visitados.arribo([vertice_aux['info'], None], 0)
else:
no_visitados.arribo([vertice_aux['info'], None], inf)
aux += 1
while (not no_visitados.vacio()):
dato = no_visitados.atencion()
camino.apilar(dato)
pos_aux = self.buscar_vertice(dato[1][0])
vertice_aux = self.inicio.obtener_elemento(pos_aux)
aristas = 0
while (aristas < vertice_aux['aristas'].tamanio()):
arista = vertice_aux['aristas'].obtener_elemento(aristas)
pos_heap = no_visitados.busqueda(arista['destino'])
if (pos_heap is not None
and no_visitados.elementos[pos_heap][0] >
dato[0] + arista['peso']):
no_visitados.elementos[pos_heap][1][1] = dato[1][0]
nuevo_peso = dato[0] + arista['peso']
no_visitados.cambiar_prioridad(pos_heap, nuevo_peso)
aristas += 1
# print(no_visitados.elementos)
return camino
def contar():
p_voc = Pila()
p_con = Pila()
po = Pila()
parrafo = 'Los hombres no son nada, los principios lo son todo.'
numeros = '0123456789'
vocales = 'aeiouAEIOU'
consonantes = 'bcdfghjklmnpqrstvwxyzBCDFGHJKLMNPQRSTVWXYZ'
print(parrafo)
for dato in parrafo:
if dato in vocales:
apilar(p_voc, dato)
elif dato in consonantes:
apilar(p_con, dato)
else:
apilar(po, dato)
# A) B) y D)
voc, cons, o, eb, n = 0, 0, 0, 0, 0
while not pila_vacia(p_voc):
desapilar(p_voc)
voc += 1
while not pila_vacia(p_con):
desapilar(p_con)
cons += 1
while not pila_vacia(po):
m = desapilar(po)
o += 1
if m == ' ':
eb += 1
elif m in numeros:
n += 1
print('Cantidad de vocales:', voc)
print('Cantidad de consonantes:', cons)
print('Cantidad de otros caracteres:', o)
print('Cantidad de espacios en blanco:', eb)
print('Cantidad de numeros:', n)
# C)
total = voc + cons + o
print('Porcentaje de vocales:', round(voc * 100 / total, 2), '%')
print('Porcentaje de consonantes:', round(cons * 100 / total, 2), '%')
# E)
if voc == o:
print('Igual cantidad de vocales y otros caracteres')
else:
print('Cantidades distintas de vocales y otros caracteres')
# F)
z = False
while not pila_vacia(p_con):
dato = desapilar(p_con)
if dato == 'z':
z = True
if z:
print('Existen letras Z en el parrafo')
def ordenar_pila():
pila = Pila()
pila_auxiliar = Pila()
while not pila_vacia(pila):
dato = random.randint(1, 50)
if not pila_vacia(pila):
while not pila_vacia(pila) and cima(pila) >= dato:
apilar(pila_auxiliar, desapilar(pila))
apilar(pila, dato)
while not pila_vacia(pila_auxiliar):
apilar(pila, desapilar(pila_auxiliar))
barrido_pila(pila)
def fibonacci(valor):
p = Pila()
p_aux = Pila()
apilar(p, 0)
apilar(p, 1)
for i in range(1, valor):
f1 = desapilar(p)
f0 = desapilar(p)
aux = f1 + f0
apilar(p, f0)
apilar(p, f1)
apilar(p, aux)
print("Fibonacci de: ", valor)
barrido(p)
def pares_impares(p):
pila_pares = Pila()
pila_impares = Pila()
while not pila_vacia(p):
aux = desapilar(p)
if (aux % 2) == 0:
apilar(pila_pares, aux)
else:
apilar(pila_impares, aux)
print("Pila de pares: --INICIO--")
barrido(pila_pares)
print("Pila de pares: --FIN--")
print("Pila de impares: --INICIO--")
barrido(pila_impares)
print("Pila de impares: --FIN--")
def peliculas():
'''Pila de peliculas y sus datos'''
pila = Pila()
c = 0
titulo = [
'Reservoir Dogs', 'Bohemian Rhapsody', 'Doctor Strange',
'Avengers: Infinity War', 'Guardianes de la galaxia'
]
estudio = [
'Marvel Studios', 'Artisan Entertainment', 'GK Films',
'Marvel Studios', 'Marvel Studios', 'Marvel Studios'
]
anio = ['1992', '2018', '2016', '2018', '2014']
for i in range(0, 6):
title, studio, year = titulo[i], estudio[i], anio[i]
apilar(pila, [title, studio, year])
print('Peliculas:')
barrido_pila(pila)
while not pila_vacia(pila):
dato = desapilar(pila)
if dato[2] == '2014':
print(str(dato[0]) + ' fue estrenada en 2014')
if dato[2] == '2018':
c += 1
if dato[1] == 'Marvel Studios' and str(dato[2]) == '2018':
print(str(dato[0]) + ' fue producida por Marvel en el año 2018')
print('Se estrenaron', c, 'peliculas en 2018')
def iesimo(pila, pos):
paux = Pila()
for i in range(0, pos):
apilar(paux, desapilar(pila))
desapilar(pila)
while not pila_vacia(paux):
apilar(pila, desapilar(paux))
def eliminar_elemento(p, pos):
pila_aux = Pila()
for i in range(0, pos):
apilar(pila_aux, desapilar(p))
desapilar(p)
while not pila_vacia(pila_aux):
apilar(p, desapilar(pila_aux))
def restringir_valores():
p = Pila()
p_aux = Pila()
while not pila_llena(p):
apilar(p, random.randint(0, 800))
print("Lista de valores: ")
barrido(p)
while not pila_vacia(p):
aux = desapilar(p)
if (aux % 2 == 0) or (aux % 3 == 0) or (aux % 5 == 0):
apilar(p_aux, aux)
while not pila_vacia(p_aux):
apilar(p, desapilar(p_aux))
print("")
print("Lista de valores que son multiplos de 2, 3 o 5")
barrido(p)
def qe_onda_el_enunciado_wtf():
cola = Cola()
cola_aux = Cola()
pila = Pila()
base = [
'Base Dantooine', 'Base Eco', 'Cuartel General de la Resistencia',
'Gran Templo de Massassi', 'Puesto de avanzada Beta'
]
latitud = [73, -23, -37, 45, 4]
longitud = [-54, 166, -72, 4, 113]
q1 = radians(randint(-90, 90))
d1 = radians(randint(-180, 180))
r = 6371
c1 = 0
c2 = 0
c3 = 0
for i in range(len(base)):
arribo(cola, [base[i], randint(10, 200), latitud[i], longitud[i]])
print('Base - Tamaño de flota - Latitud - Longitud')
barrido_cola(cola)
print('La coordenada actual es :', round(q1, 6), ',', round(d1, 6))
while not cola_vacia(cola):
x = atencion(cola)
q2 = radians(x[2])
d2 = radians(x[3])
formula = 2 * r * asin(
sqrt(
sin((q1 - q2) / 2)**2 +
cos(q1) * cos(q2) * sin((d1 - d2) / 2)**2))
dist = int(formula)
print(x[0] + ' se encuentra a ' + str(dist) + 'km')
apilar(pila, [dist, x[0], x[1]])
arribo(cola_aux, [x[1], x[0], dist])
print()
pila = ordenar(pila)
c1 = desapilar(pila)
c2 = desapilar(pila)
c3 = desapilar(pila)
print('Las tres bases mas cercanas son:')
print(c1[1] + ' se encuentra a ' + str(c1[0]) + 'km')
print(c2[1] + ' se encuentra a ' + str(c2[0]) + 'km')
print(c3[1] + ' se encuentra a ' + str(c3[0]) + 'km')
if c1[2] > c2[2] and c1[2] > c3[2]:
print(c1[1] + ' posee la mayor flota aerea')
elif c2[2] > c1[2] and c2[2] > c3[2]:
print(c2[1] + ' posee la mayor flota aerea')
else:
print(c3[1] + ' posee la mayor flota aerea')
print()
barrido_cola(cola_aux)
cont = 0
while not cola_vacia(cola_aux):
dato = atencion(cola_aux)
if dato[0] > cont:
cont = dato[0]
info = dato
print()
print(info[1], 'posee la mayor flota(' + str(info[0]) + ')')
print('Se encuentra a:', info[2], 'km')
def invertir(p):
pila_aux = Pila()
print('Pila original: ')
barrido(p)
while not pila_vacia(p):
apilar(pila_aux, desapilar(p))
print('Pila invertida: ')
barrido(pila_aux)
def ej_factorial(n):
pila = Pila()
aux = 1
for i in range(1, n + 1):
apilar(pila, i)
while not pila_vacia(pila):
aux = aux * desapilar(pila)
print('Factorial del numero ingresado: ', str(aux))
def invertir_cola(cola):
pila = Pila()
while not cola_vacia(cola):
apilar(pila, atencion(cola))
while not pila_vacia(pila):
arribo(cola, desapilar(pila))
print('Cola invertida: ')
barrido_cola(cola)
def factorial(num):
p = Pila()
aux = 1
for i in range(1, num + 1):
apilar(p, i)
while not pila_vacia(p):
aux = aux * desapilar(p)
print('El factorial de ', num, 'es', aux)
def caminoMasCortoAristasPunto5(grafo, origen, destino, campo=0):
camino = dijkstraAristasPunto5(grafo, origen, destino, campo)
pila = Pila()
while (not pila_vacia(camino)):
dato = desapilar(camino)
if (destino == dato[1][0].info):
apilar(pila, dato[1][0].info)
destino = dato[1][1]
while (not pila_vacia(pila)):
print(desapilar(pila))
def palabra_invertida(cadena):
p = Pila()
aux = len(cadena)
cadena_aux = ''
for i in range(0, aux):
car = cadena[i]
apilar(p, car)
while not pila_vacia(p):
cadena_aux = cadena_aux + desapilar(p)
print(cadena_aux)
def inversa(palabra):
pila = Pila()
aux = len(palabra)
palabra_auxiliar = ''
for i in range(0, aux):
c = palabra[i]
apilar(pila, c)
while not pila_vacia(pila):
palabra_auxiliar = palabra_auxiliar + desapilar(pila)
print(palabra_auxiliar)
def caminoMasCortoPunto10(grafo, origen, destino, campo=0):
camino = dijkstraPunto10(grafo, origen, destino, campo)
pila = Pila()
while (not pila_vacia(camino)):
dato = desapilar(camino)
if (destino == dato[1][0].info['nombre']):
apilar(pila, dato[1][0].info['nombre'])
destino = dato[1][1]
while (not pila_vacia(pila)):
print(desapilar(pila))
def palindromo(cadena):
p = Pila()
aux = len(cadena)
cadena_aux = ''
for i in range(0, aux):
car = cadena[i]
apilar(p, car)
while not pila_vacia(p):
cadena_aux = cadena_aux + desapilar(p)
if cadena == cadena_aux:
print("la palabra es palindromo")
def palabras():
serie_palabras = [
"Guitarra", "Fotocopia", "Roedor", "Fecha", "Batir", "Horno",
"Compartimiento", "Amazona", "Tabaco"
]
p = Pila()
p_aux = Pila()
for i in range(0, len(serie_palabras)):
apilar(p, serie_palabras[i])
print("Palabras con mas de 7 caracteres")
while not pila_vacia(p):
aux = desapilar(p)
if len(aux) > 7:
print(aux)
apilar(p_aux, aux)
while not pila_vacia(p_aux):
apilar(p, desapilar(p_aux))
print("")
print("Lista de palabras")
barrido(p)
def pila_par(pila):
paux = Pila()
aux = 0
while not pila_vacia(pila):
aux = desapilar(pila)
if aux % 2 == 0:
apilar(paux, aux)
while not pila_vacia(paux):
apilar(pila, desapilar(paux))
print('La pila con numeros pares es: ')
barrido_pila(pila)
def objetos_oficina():
objetos = [
"escritorio", "silla", "teclado", "mouse", "monitor", "gabinete"
]
peso = [10.5, 5, 0.800, 0.400, 2.5, 5]
pila_oficina = Pila()
for i in range(0, len(objetos)):
apilar(pila_oficina, [peso[i], objetos[i]])
pila_ordenada = ordenar_pila(pila_oficina)
print('Pila ordenada')
barrido(pila_ordenada)
def pila_pares(p):
pila_aux = Pila()
aux = 0
while not pila_vacia(p):
aux = desapilar(p)
if (aux % 2) == 0:
apilar(pila_aux, aux)
while not pila_vacia(pila_aux):
apilar(p, desapilar(pila_aux))
print('Pila con pares: ')
barrido(p)
def palindromo(palabra):
pila = Pila()
aux = len(palabra)
palabra_auxiliar = ''
for i in range(0, aux):
c = palabra[i]
apilar(pila, c)
while not pila_vacia(pila):
palabra_auxiliar = palabra_auxiliar + desapilar(pila)
if palabra == palabra_auxiliar:
print('es palindromo')