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 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 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 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 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 = Stack()
for _ in range(0, 2):
data.put(input("Data : "))
data_reversed = Stack()
for _ in range(0, len(data)):
data_reversed.put(data.get())
return data_reversed
def is_valid(string: str) -> bool:
"""
Premise for this operation is that if the opening bracket matches the closing bracket next to it, remove from the stack
If the stack isn't empty after iterating through the whole process, it's invalid.
:type string: str
:rtype: bool
"""
stack = Stack()
opens = ['{', '[', '(']
closes = ['}', ']', ')']
matches = {'[': ']', '{': '}', '(': ')'}
if len(string) == 0:
return False
for bracket in string:
if bracket in opens:
stack.push(bracket)
if bracket in closes:
x = stack.top()
y = matches[stack.top()]
if bracket == matches[stack.top()]:
stack.pop()
else:
# i.e. ( ] is invalid always
return False
if stack.length() == 0:
return True
else:
return False
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 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 string_and_structs(string: str) -> tuple:
# TODO: Parcourez la chaîne de caractères.
# Si le caractère est une lettre, on l'ajoute dans fifo.
# Sinon, on retire un élément de fifo pour l'insérer dans lifo.
fifo, lifo = Queue(), Stack()
return fifo, lifo
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 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 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 = Stack()
# Demander les valeurs ici
for n in range(10):
data.put(input(f"Veuillez entrer une valeur ({n+1} de 10): "))
else:
pass
# Stocker le résultat ici
reversed_data = Stack()
for n in range(len(data)):
reversed_data.put(data.get())
return reversed_data
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.
# On utilise une pile (Stack) ici
if data is None:
# Demander les valeurs ici
data = Stack()
for i in range(10):
data.put(int(input('Entrer un nombre : ')))
reversed_data = Stack()
# Stocker le résultat ici
for i in range(len(data)):
reversed_data.put(data.get(i))
return reversed_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_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 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 string_and_structs(string: str) -> tuple:
# TODO: Parcourez la chaîne de caractères.
# Si le caractère est une lettre, on l'ajoute dans fifo.
# Sinon, on retire un élément de fifo pour l'insérer dans lifo.
fifo, lifo = Queue(), Stack()
for char in string:
if 65 <= ord(char) <= 90 or 97 <= ord(char) <= 122:
fifo.put(char)
else:
lifo.put(fifo.get())
return fifo, lifo
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.
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 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.
if data is None:
data = [input("Enter a value: ") for _ in range(10)]
reversed_data = Stack(len(data))
for x in range(len(data) - 1, -1, -1):
reversed_data.put(data[x])
return reversed_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 init_stack(self, batch_size):
"""
Initializes the neural data structure to contain a given number
of zero vectors.
:type batch_size: int
:param batch_size: The total number of vectors that may be
placed onto the neural data structure
:return: None
"""
self.read = Variable(torch.zeros([batch_size, self.read_size]))
self.stack = Stack(batch_size, self.read_size, k=self.k)
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.
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:
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 string_and_structs(string: str) -> tuple:
# TODO: Parcourez la chaîne de caractères.
# Si le caractère est une lettre, on l'ajoute dans fifo.
# Sinon, on retire un élément de fifo pour l'insérer dans lifo.
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
fifo, lifo = Queue(), Stack()
for letter in string:
if letter in alphabet:
fifo.put(letter)
else:
lifo.put(fifo.get())
return fifo, lifo
def string_and_structs(string: str) -> tuple:
# TODO: Parcourez la chaîne de caractères.
# Si le caractère est une lettre, on l'ajoute dans fifo.
# Sinon, on retire un élément de fifo pour l'insérer dans lifo.
fifo, lifo = Queue(), Stack()
for i in string:
if i.isalpha():
fifo.put(i)
else:
lifo.put(fifo.get())
return fifo, lifo
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))]
