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 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
temp = [data.get() for _ in range(len(data))]
temp.sort()
data.put_many(temp)
return data
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 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 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 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.
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 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.
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.
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 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.
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 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 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 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 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:
s = Stack()
[data.get() for i in range(len(data)) if i != len(data) - position]
# TODO: Supprimer le énième (position) élément de data et retourner la nouvelle structure de données.
for i in range(data):
if i == len(data) - position:
data.get()
else:
s.put(data.get())
return [s.get() for _ in range(len(s))]
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 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 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 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)- position):
s.put(data.get())
data.get()
return 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 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.
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 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)
class Model(nn.Module):
"""
Abstract class for creating policy controllers (models) that
operate a neural data structure, such as a neural stack or a neural
queue. To create a custom model, create a class inhereting from
this one that overrides self.__init__ and self.forward.
"""
__metaclass__ = ABCMeta
def __init__(self, read_size, struct_type=Stack, k=None):
"""
Constructor for the Model object.
:type read_size: int
:param read_size: The size of the vectors that will be placed on
the neural data structure
:type struct_type: type
:param struct_type: The type of neural data structure that this
Model will operate. Please pass the *class* for the
data structure type to this parameter, not a specific
instance of that class
"""
super(Model, self).__init__()
self.read_size = read_size
self.struct_type = struct_type
self.k = k
self.read = None
self.stack = None
@abstractmethod
def forward(self, x):
"""
Computes the output of the neural network given an input. The
controller should push a value onto the neural data structure and
pop one or more values from the neural data structure, and
produce an output based on this information and recurrent state
if available.
:param x: The input to the neural network
:return: The output of the neural network
"""
raise NotImplementedError("Missing implementation for forward")
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 read_stack(self, v, u, d):
self.read = self.stack.forward(self.v, self.u, self.d)
# If we want multiple read vectors
if self.k is not None:
self.read = tf.cat(tf.unbind(self.read, dim=1), dim=1)
# TODO verify this
def get_read_size(self):
"""
Return the effective read size, taking k into account.
"""
k = 1 if self.k is None else self.k
return self.read_size * k
@staticmethod
def init_normal(tensor):
n = tensor.data.shape[0]
tensor.data.normal_(0, 1. / np.sqrt(n))
def trace(self, trace_X):
"""
Visualize stack activations for a single training sample.
Draws a graphic representation of these stack activations.
@param trace_X [1, max_length, input_size] tensor
"""
self.eval()
self.init_stack(1)
max_length = trace_X.data.shape[1]
data = np.zeros([2 + self.read_size, max_length]) # 2 + len(v)
for j in xrange(1, max_length):
self.forward(trace_X[:, j - 1, :])
data[0, j] = self.u.data.numpy()
data[1, j] = self.d.data.numpy()
data[2:, j] = self.v.data.numpy()
plt.imshow(data, cmap="hot", interpolation="nearest")
plt.show()
""" Compatibility """
def init_struct(self, *args, **kwargs):
self.init_stack(*args, **kwargs)
return
