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
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