Wie kann man eine ADT verbessern?

Question

Ich werde ein ADT entwerfen und implementieren, das ein unfaires Set darstellt. Ein Set ist ein ADT, der den gleichen Regeln folgt wie echte Sets, neue Items werden auf der Rückseite des Sets hinzugefügt (pushing) und alte Items werden von der Vorderseite des Sets entfernt (popping).

Wenn ich versuche, einen Wert hinzuzufügen, der bereits im Set existiert, passiert nichts. Dies ist das erwartete Standardverhalten für eine Gruppe. Der Unterschied zwischen einem normalen Satz und dem unfairen Satz, den ich einreichen werde, besteht darin, dass wenn ich einen Großbuchstaben auf das Set drücke, es hinzugefügt werden sollte, unabhängig davon, ob es bereits in dem Satz existiert.

Der obere Inhalt ist die Frage, die ich gegenüberstelle.

Der Code, den ich zu schreiben versucht:

class Set: 
class Full(Exception): 
    pass 
class Empty(Exception): 
    pass 


def __init__(self, data=None): 

    """ Show the set base and the data are inside the dictionary""" 
    self.data = {} # the dictionary of the set 
    if data != None: 
     if len(data) != len(set(data)): 
      data = set(data) 
     for d in data: 
      self.data[d] = d 

def add(self, value): 

    """This function show how to add value in to the set, if value 
     in the set, it will return a message and stop the process. Else, 
     The new value will add into the set""" 

    if value in self.data.keys(): 
     return 'This word is already in set' 
    else: 
     self.data[value] = value # value == key, so it only show the value is store 

def remove(self, value): 

    """This function is use for removing value from the set, 
     if the value is not in the set, it will return a message""" 

    if value not in self.data.keys(): 
     return 'No value found in the set' 
    self.data.pop(value) 

def size(self): 

    """ Returns the number of values currently stored in the 
     set """ 

    return len(self.data.keys()) 

def is_in(self, value): 

    """ This funiction use for test is the current value save in 
     teh set, if yes it will return true. Else return false.""" 

    if i in self.data.keys(): 
     return True 
    else: 
     return False 


def is_in(self, value): 

    """ This funiction use for test is the current value save in 
     teh set, if yes it will return true. Else return false.""" 

    if i in self.data.keys(): 
     return True 
    else: 
     return False 

Die Funktionen, die ich im Programm ausgeführt werden soll:

• size sollte die aktuelle Größe des unfairen Satz zurückzukehren.
• add sollte dem unfairen Satz ein bestimmtes Zeichen hinzufügen.
• remove sollte ein bestimmtes Zeichen aus der unfairen Menge entfernen, in Fällen, in denen Großbuchstaben mehrfach gespeichert sind, sollte eine davon entfernt werden.
• is_in sollte angeben, ob ein bestimmtes Zeichen derzeit in der unfairen Gruppe gespeichert ist.

Wie kann ich sie verbessern, ohne mindestens 100 Wörter jede set oder frozenset in Python-Bibliothek und Speicher zu verwenden?

Answer 1

Sie haben eine Sache, die sich in einer Weise (als eine Menge) mit einer Art von Wert (alles, was kein Großbuchstabe ist) verhält, und eine andere Weise (als Tasche) mit einer anderen Art von Eingabe (alles was ein ist Großbuchstabe).

Die einfachste Möglichkeit zur Lösung dieser Art von Problem besteht darin, Instanzen der Typen zu aggregieren, die die beiden Verhaltensweisen in ein Objekt implementieren, und eine Schnittstelle bereitzustellen, die die Instanzen basierend auf dem Wert sendet. Zum Beispiel sollte es möglich sein, einen Satz und einen counter zu verwenden und zwischen ihnen zu wählen, basierend darauf, ob der Wert in Großbuchstaben ist. Sie können auch mit einem Zähler oder einem Diktat davonkommen und den Eintrag basierend auf dem Wert dekrementieren oder vollständig entfernen.

reale Sätze, neue Gegenstände werden auf der Rückseite des Satzes hinzugefügt (schieben) und alte Gegenstände werden von der Vorderseite des Satzes entfernt (knallend).

Die übliche Verwendung von Set-Datenstrukturen hat keine "Front" oder "Rückseite", da sie ungeordnet sind. Der Satz "echte Mengen" macht nicht viel Sinn - sie sind schließlich ein abstrakter Datentyp.