FAOD-DUI4/pile.py

class Node:
    """La classe ```Node``` sera un noeud (une case, un emplacement, ...) où l'on stockera notre donnée

    Les objets de cette classe ont deux attributs:

    value: qui correspond à la valeur stockée
    nxt: la référence vers le prochain élément

    """

    def __init__(self, value=None, nxt=None) -> None:
        """Initialisation du "node"

        :param value: valeur à stocker dans ce "node"
        :param nxt: Node du prochain élément

        :consignes: compléter l'initialisation de la classe.

        :example:
        >>> n1 = Node(1)
        >>> assert n1.value == 1
        >>> assert n1.nxt is None
        >>> n2 = Node(5, n1)
        >>> assert n1.value == 5
        >>> assert n1.nxt == n1
        >>> n3 = Node("a", n2)
        >>> assert n1.value == "a"
        >>> assert n1.nxt == n3
        """
        pass


class Pile:
    """
    La classe ```Pile``` doit posséder un élément "courant" qui est l'élément sur le dessus de la pile.

    Fonctionnement d'une pile

      -----------
      _ _ _ _ _ <---- append
      -----------

      -----------
      _ _ _ _ _ ----> pop
      -----------


    Elle doit aussi posséder un entier ```n``` qui compte le nombre d'éléments dans la pile

    Cette classe aura donc 2 attributs:
    - current avec l'élément courant
    - n avec le nombre d'éléments dans la pile

    :consignes: Compléter les méthodes suivantes.
    """

    def __init__(self) -> None:
        """Initialisation de la Pile vide

        :example:
        >>> pile = Pile()
        >>> assert pile.n == 0
        >>> assert pile.current is None
        """
        # -----------------------

        # -----------------------
        pass

    def append(self, value):
        """Ajoute "value" dans la pile

        :example:
        >>> pile = Pile()
        >>> pile.append(1)
        >>> assert pile.n == 1
        >>> assert pile.current == 1
        >>> pile.append("a")
        >>> assert pile.n == 2
        >>> assert pile.current == "a"
        """
        # -----------------------

        # -----------------------
        pass

    def get_current(self):
        """Renvoie la prochaine valeur sans l'enlever de la pile
        Si la liste est vide, la fonction renvoie None.

        :example:
        >>> pile = Pile()
        >>> pile.get_current()
        None
        >>> pile.append(3)
        >>> pile.get_current()
        3
        >>> pile.get_current()
        3
        """
        # -----------------------

        # -----------------------
        pass

    def is_empty(self):
        """Vérifie si le pile est vide

        :example:
        >>> pile = Pile()
        >>> pile.is_empty()
        True
        >>> pile.append(1)
        >>> pile.is_empty()
        False

        """
        # -----------------------

        # -----------------------
        pass

    def pop(self):
        """Renvoie le prochain élément de la pile et l'enlève.

        Comme c'est une pile, le prochain élément est le dernier élément arrivé.

        Si la liste est vide, la fonction renvoie None.

        :example:
        >>> pile = Pile()
        >>> pile.pop()
        None
        >>> pile.append(2)
        >>> pile.pop()
        2
        >>> pile.pop()
        None
        >>> pile.append(2)
        >>> pile.append(5)
        >>> pile.append("a")
        >>> pile.pop()
        'a'
        >>> pile.pop()
        5
        >>> pile.pop()
        2
        >>>

        """
        # -----------------------

        # -----------------------
        pass

    def empty(self):
        """vide la pile c'est à dire element tous les elements de cette dernière

        :example:
        >>> pile = Pile()
        >>> pile.append(3)
        >>> pile.append(5)
        >>> pile.append("a")
        >>> pile.get_current()
        "a"
        >>> assert pile.n == 3
        >>> pile.empty()
        >>> pile.get_current()
        None
        >>> assert pile.n == 0
        """
        # -----------------------

        # -----------------------
        pass