def delete_nth_from_stack(data: Stack, position: int) -> list:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
result = Stack()
for _ in range(len(data) - position):
result.put(data.get())
data.get()
for _ in range(len(result)):
data.put(result.get())
return data
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
s = Stack()
for i in range(len(data)):
if i == len(data) - position:
data.get()
else:
s.put(data.get())
return [s.get() for _ in range(len(s))]
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
temp_stack = Stack()
for i in range(len(data) - position - 1):
temp_stack.get(data.put(i))
data.put(position)
for i in range(len(data)):
data.get(temp_stack.put(i))
return data
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
result = Stack()
for i in range(len(data)): # Stack donc on part de la fin jusqu'au début
if i == len(data) - position:
data.get()
else:
result.put(data.get())
return [result.get() for _ in range(len(result))]
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
temp = Stack()
for removedEl in range(len(data) -
position): # Sortir les elements jusqu'a position
temp.put(data.get())
data.get() # retirer l'element a la position n
for putEl in range(len(temp)): # remettre les elements dans data
data.put(temp.get())
return data
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
temp = [
data.get() for _ in range(len(data) - position - 1)
] # -1 car une valeur ne doit pas être mise dans la liste temporaire
data.get()
temp.reverse()
data.put_many(temp)
return data
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
#Voir solutions screenshots du 5 octobre
x = Stack()
y = len(data)
for i in range(len(data)):
if i == y - position - 1:
data.get()
else:
x.put(data.get())
return [x.get() for _ in range(len(x))]
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
for i in range(len(data)):
if i == (len(data) - position):
print(
f"L'element a supprimer est {data.get()} a la position {position}."
)
data.get()
else:
data.put(data.get())
new_stack = Stack()
new_stack.put_many(data.get() for _ in range(len(data)))
return new_stack
def delete_nth_from_stack(data: Stack, position: int) -> Stack:
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
return Stack()
s = Stack()
for i in range(len(data) - 1):
s.put(data.get())
def sort_stack(data: Stack) -> Stack:
# TODO: Retourner la séquence
values = []
for _ in range(len(data)):
values.append(data.get())
data.put_many(sorted(values))
return data
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
if data is None:
data = [input('Saisir : ') for i in range(10)]
s = Stack()
for d in data:
s.put(d)
return [s.get() for i in range len(s)]
listey = deque()
#for i in range(4-nombre):
#listey.append(liste.pop())
#for i in range(0,nombre-1):
#listey.append(liste[i])
reversed_data = None # Stocker le résultat ici
return reversed_data
def sort_stack(data: Stack) -> Stack:
# TODO: Retourner la séquence triée
sortedStack = Stack()
sortedStack.put_many(
sorted([data.get() for el in range(len(data))])
) # Ordonner une liste faite par comprehension, et l'ajouter a sortedStack
return sortedStack
def sort_stack(data: Stack) -> Stack:
# TODO: Retourner la séquence triée
temp = [data.get() for _ in range(len(data))]
temp.sort()
data.put_many(temp)
return data
def sort_stack(data: Stack) -> Stack:
#STACK = LAST IN FIRST OUT
sorted_stack = Stack()
# [1, 3, 2, 4, 8, 5]
#5,8,4,2,3,1
sorted_stack.put_many(sorted([data.get() for _ in range(len(data))]))
return sorted_stack
def sort_stack(data: Stack) -> Stack:
# TODO: Retourner la séquence triée
x = Stack()
values = []
for i in range(len(data)):
values.append(data.get())
x.put_many(sorted(values))
return x
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
if data is None:
data = [input("Entrez une valeur: ") for _ in range(10)]
# Stocker le résultat ici
s = Stack()
s.put_many(data)
return [s.get() for _ in range(len(s))]
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
stack, MAX = Stack(), 10
if data is None:
stack.put_many(
input(f"Entrez la valuer {i} ici -> ") for i in range(MAX))
reversed_data = [stack.get() for _ in range(MAX)]
return reversed_data
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
if data is None: # Demander les valeurs ici
data = [input("Entrez une valeur : ") for _ in range(10)]
reversed_data = Stack()
reversed_data.put_many(data) # Stocker le résultat ici
return [reversed_data.get() for _ in range(10)
] # Poper les valeurs pour les avoir dans le sens inverse
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
if data is None:
fifo = Stack()
for number in range(0, 10):
fifo.put(int(input("Donnez un nombre: ")))
reversed_data = [fifo.get() for number in range(0, 10)]
# Stocker le résultat ici
return reversed_data
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
if data is None:
data = [input('Entrez une donnee') for _ in range(10)]
s = Stack()
for d in data:
s.put(d)
return [s.get() for _ in range(len(s))]
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
lifo = Stack()
if data is None:
pass # Demander les valeurs ici
for i in range(10):
data = input('veuillez entrez un nombre: ')
lifo.put(data)
reversed_data = None # Stocker le résultat ici
reversed_data = []
while not lifo.empty():
reversed_data.append(lifo.get())
return reversed_data
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
if data is None:
data = [input("entrez une donnee:") for _ in range(10)]
s = Stack()
s.put_many(
data
) #on met la liste dans un stack = pille et on fait des pop (get)dessus pour le mettre en ordre de last in first out dans une liste
# ensuite une fois que on as accès à tout les valeurs de notre pille on peut agir dessus
for d in data:
s.put(d)
return [s.get() for _ in range(len(s))]
def reverse_data(data: list = None):
# TODO: Demander 10 valeurs à l'utilisateur,
# les stocker dans une structure de données,
# et les retourner en ordre inverse, sans utiliser de liste.
reversed_data = Stack()
if data is None:
data = [input("Veuillez entre une valeur") for _ in range(10)]
reversed_data.put_many(data)
liste = []
for _ in range(len(reversed_data)):
liste.append(reversed_data.get())
#ou simplement return [reversed_data.get() for _ in range(len(reversed_data))]
return liste
def sort_stack(data: Stack) -> Stack:
# TODO: Retourner la séquence triée
data_list = [data.get() for _ in range(len(data))]
data.put_many(sorted(data_list))
return data
