Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- #PARCIALITO 3
- #----------------------------------------------------------------
- #BASICOS PILAS
- class Pila:
- """ Representa una pila con operaciones de apilar, desapilar y
- verificar si está vacía. """
- def __init__(self):
- """ Crea una pila vacía. """
- # La pila vacía se representa con una lista vacía
- self.items=[]
- def apilar(self, x):
- """ Agrega el elemento x a la pila. """
- # Apilar es agregar al final de la lista.
- self.items.append(x)
- def desapilar(self):
- """ Devuelve el elemento tope y lo elimina de la pila.
- Si la pila está vacía levanta una excepción. """
- try:
- return self.items.pop()
- except IndexError:
- raise ValueError("La pila está vacía")
- def esta_vacia(self):
- """ Devuelve True si la lista está vacía, False si no. """
- return self.items == []
- def __str__(self):
- return str(self.items)
- def generar_pila():
- pilar=Pila()
- lista=["hola","hola","si",1,5,"jaja"]
- for elemento in lista:
- pilar.apilar(elemento)
- return pilar
- #----------------------------------------------------------------
- """1. Escribir una funci´on reemplazar que tome una Pila, un valor nuevo y un
- valor viejo y reemplace en la Pila todas las ocurrencias de valor viejo por valor
- nuevo. Considerar que la Pila tiene las primitivas apilar(dato), desapilar() y
- esta vacia()."""
- def reemplazar(pilita,valor_nuevo,valor_viejo):
- pila_aux=Pila() #crea una pila vacia
- while not pilita.esta_vacia():
- elemento=pilita.desapilar()
- if elemento==valor_viejo:
- pila_aux.apilar(valor_nuevo)
- else:
- pila_aux.apilar(elemento)
- while not pila_aux.esta_vacia(): #vuelve a acomodar la pila inicial (pilita)
- item=pila_aux.desapilar()
- pilita.apilar(item)
- print(pilita)
- return pilita
- pilar=generar_pila()
- reemplazar(pilar,"ANITAAA","hola")
- #----------------------------------------------------------------
- """3. Escribir una funci´on que reciba una pila de n´umeros y elimine de la misma
- los elementos consecutivos que est´en repetidos. Se pueden usar estructuras auxiliares.
- La funci´on no devuelve nada, simplemente modifica los elementos de la pila
- que recibe por par´ametro.
- Por ejemplo: remover duplicados consecutivos(Pila([2, 8, 8, 8, 3, 3, 2, 3, 3, 3, 1, 7]))
- Genera: Pila([2, 8, 3, 2, 3, 1, 7])."""
- def remover_duplicados_consecutivos(pila_numeros):
- pila_aux=Pila()
- while not pila_numeros.esta_vacia():
- elemento=pila_numeros.desapilar()
- if not pila_aux.esta_vacia() and pila_aux.ver_tope()!=elemento:
- pila_aux.apilar(elemento)
- elif pila_aux.esta_vacia():
- pila_aux.apilar(elemento)
- while not pila_aux.esta_vacia():
- item=pila_aux.desapilar()
- pila_numeros.apilar(item)
- print(pila_numeros)
- pilar=generar_pila()
- remover_duplicados_consecutivos(pilar)
- #----------------------------------------------------------------
- S_APERTURA=["(","[","{"]
- S_CIERRE=[")","]","}"]
- def esta_balanceada(expresion):
- pila=Pila()
- for elemento in expresion:
- if elemento in S_APERTURA:
- pila.apilar(elemento)
- elif elemento in S_CIERRE:
- if pila.esta_vacia():
- return False
- elem_tope=pila.desapilar()
- pos=S_APERTURA.index(elem_tope)
- if elemento!=S_CIERRE[pos]:
- return False
- return True
- #----------------------------------------------------------------
- #LISTA ENLAZADA
- class _Nodo():
- def __init__(self,dato=None,prox=None):
- self.dato=dato
- self.prox=prox
- def __str__(self):
- return str(self.dato)
- class _IteradorListaEnlazada:
- def __init__(self,prim):
- self.actual=prim
- def __next__(self):
- if self.actual is None:
- raise StopIteration()
- dato=self.actual.dato
- self.actual=self.actual.prox
- return dato
- class ListaEnlazada(object):
- def __init__(self):
- self.prim=None
- self.len=0
- def insert(self, i, x):
- """ Inserta el elemento x en la posición i.
- Si la posición es inválida, levanta IndexError """
- if (i > self.len) or (i < 0):
- raise IndexError("Posición inválida")
- nuevo = _Nodo(x)
- if i == 0:
- nuevo.prox = self.prim
- self.prim = nuevo
- else:
- n_ant = self.prim
- for pos in range(1,i):
- n_ant = n_ant.prox
- nuevo.prox = n_ant.prox
- n_ant.prox = nuevo
- self.len += 1
- def __len__(self):
- return self.len
- def append(self,x):
- self.insert(len(self),x) #len(self) es la última posición
- def __str__(self):
- cadena=""
- n_act=self.prim
- while n_act is not None:
- cadena+=str(n_act.dato)+","
- n_act=n_act.prox
- return "[{}]".format(cadena.rstrip(","))
- def __iter__(self):
- return _IteradorListaEnlazada(self.prim)
- def invertir(self):
- anterior=None
- actual=self.prim
- siguiente=actual.prox
- while actual:
- actual.prox=anterior
- anterior=actual
- actual=siguiente
- if siguiente:
- siguiente=siguiente.prox
- self.prim=anterior
- #crear la lista
- lista=ListaEnlazada()
- lista.append(15)
- lista.append(17)
- #----------------------------------------------------------------
- #COLAS
- #OJO; SE UTILIZA LISTA ENLAZADA, USE LA LISTA DE PYTHON PARA VERIFICAR LOS EJERCICIOS MAS FACILMENTE.
- class Cola:
- def __init__(self):
- """ Crea una cola vacía. """
- # La cola vacía se representa por una lista vacía
- self.items=[]
- def encolar(self, x):
- self.items.append(x)
- def desencolar(self):
- try:
- return self.items.pop(0)
- except:
- raise ValueError("La cola está vacía")
- def esta_vacia(self):
- return self.items == []
- def ver_tope(self):
- return self.items[-1]
- def generar_cola():
- lista=[1,2,5,5,28]
- cola_prueba=Cola()
- for elemento in lista:
- cola_prueba.encolar(elemento)
- return cola_prueba
- #----------------------------------------------------------------
- """6. Escribir una función “reducir” que reciba por parámetro una cola y una función
- f de dos parámetros, y aplique sucesivamente la función f a los dos primeros
- elementos de la cola (luego de desencolarlos) y encole el resultado, hasta que sólo
- quede un elemento. La función “reducir” debe devolver el ´unico elemento restante
- en la cola."""
- def sumar(n1,n2):
- return n1+n2
- def reducir(cola,f):
- cola_nueva=Cola()
- while not cola.esta_vacia():
- try:
- elemento1=cola.desencolar()
- elemento2=cola.desencolar()
- sumatoria=f(elemento1,elemento2)
- cola_nueva.encolar(sumatoria)
- except ValueError: #la cola esta vacia
- return elemento1
- cola_prueba=generar_cola()
- reducir(cola_prueba,sumar)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement