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 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 main() -> None:
print("On inverse des données...")
print(f"Résultat: {reverse_data()}")
n = 4
lifo = Stack()
lifo.put_many([i for i in range(20)])
print(
f"On retire l'élément à la position {n} de la pile et on obtient: {delete_nth_from_stack(lifo, n)}"
)
n = 6
fifo = Queue()
fifo.put_many([i for i in range(20)])
print(
f"On retire l'élément à la position {n} de la file et on obtient: {delete_nth_from_queue(fifo, n)}"
)
lifo = Stack()
lifo.put_many([randint(0, 1000) for _ in range(20)])
print(f"On ordonne une file: {sort_stack(lifo)}")
fifo = Queue()
fifo.put_many([randint(0, 1000) for _ in range(20)])
print(f"On ordonne une file: {sort_queue(fifo)}")
sequence = "te!eYy.E6e/T"
print(
f"Le résulat de la manipulation de la séquence: {string_and_structs(sequence)}"
)
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 main() -> None:
# print("On inverse des données...")
# print(f"Résultat: {reverse_data()}")
n = 4
lifo = Stack()
lifo.put_many([i for i in range(20)])
print(
f"On retire l'élément à la position {n} de la pile et on obtient: {delete_nth_from_stack(lifo, n)}"
)
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 test_sort_stack(self):
values = [randint(0, 1000) for _ in range(20)]
lifo = Stack()
lifo.put_many(values)
output = exercice.sort_stack(lifo)
answer = Stack()
answer.put_many(sorted(values))
self.assertEqual(output, answer, 'Mauvaise reponse')
def test_delete_stack(self):
lifo = Stack()
lifo.put_many(list(range(20)))
answer = Stack()
answer.put_many(list(range(19)))
output = exercice.delete_nth_from_stack(lifo, len(lifo) - 1)
self.assertEqual(output, answer, 'Mauvaise reponse')
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 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 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 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 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 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(data):
if i == len(data) - position:
data.get()
else:
s.put(data.get())
new_stack = Stack()
return new_stack.put_many([s.get() for _ in range(len(s))])
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
