#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)