We bouwen een klasse SequentieIdentiek. Elk object van deze klasse houdt een reeks waarden bij, waarbij de volgorde van belang is. Bijkomende voorwaarde is dat elke waarde hoogstens n keer mag voorkomen.

Programmeer in de klasse SequentieIdentiek het volgende:

• een constructor met 2 argumenten, namelijk:
  • de waarde van n (geheel en strikt positief)
  • een lijst waarden, die toegevoegd worden aan het geconstrueerd object, in de volgorde waarin ze voorkomen in deze lijst. Komt in deze argumentlijst een waarde meer dan $$n$$ keer voor, dan wordt het $$n+1$$, $$n+2$$, ... voorkomen van die waarde in de argumentlijst genegeerd (de eerste $$n$$ keer worden dus opgenomen in het te construeren object)
• de methode __str__() levert een string-gedaante van de vorm $$\verb![n,lijst]!$$. Hierbij wordt dus de waarde van n weergegeven en de standaardgedaante van de lijst waarden opgeslagen in het object, gescheiden door een komma en het geheel tussen vierkante haakjes teruggegeven.
• de opdracht "a == b" (met $$a$$ en $$b$$ objecten van de klasse SequentieIdentiek) levert als resultaat "True" indien de $$n$$-waarden van $$a$$ en $$b$$ gelijk zijn, alsook de lijsten van waarden die ze beiden bevatten. De opdracht levert "False" in alle andere gevallen.
• een geschikte methode __repr__()
• elk object van deze klasse is oproepbaar en de oproep s(i) levert van de SequentieIdentiek s het element op positie i van dit object. Je mag aannemen dat het argument een geldige index voorstelt.
• de opdracht "a + b" (met $$a$$ en $$b$$ objecten van de klasse SequentieIdentiek), levert een nieuw object van de klasse SequentieIdentiek, met:
  • de $$n$$-waarde van het $$a$$-object
  • alle elementen uit $$a$$ overgenomen worden (in de volgorde waarin ze in $$a$$ voorkomen), aangevuld met alle waarden uit $$b$$, waarbij de beperking geldt dat elke waarde in het resultaat hoogstens $$n$$ keer kan voorkomen ($$n$$-waarde van het $$a$$-object)
• de opdracht "a - b" (met $$a$$ en $$b$$ objecten van de klasse SequentieIdentiek), levert een nieuw object van de klasse SequentieIdentiek, met:
  • de $$n$$-waarde van het $$a$$-object
  • alle elementen uit $$a$$ initieel overgenomen worden (in de volgorde waarin ze in $$a$$ voorkomen) in het resultaat. Vervolgens worden alle waarden die in $$b$$ voorkomen, uit het resultaat verwijderd. Dit gebeurt in de volgorde waarin de waarden in $$b$$ voorkomen, waarbij voor elk element uit $$b$$ de eerste keer dat het voorkomt in het resultaat verwijderd wordt. Komt eenzelfde waarde meerdere keren in $$b$$ voor, dan wordt ook geprobeerd dit meerdere keren uit het resultaat te verwijderen

Voorbeeld

s = SequentieIdentiek(3, [1, 2, 2, 3, 3, 3]*3 + [4])
print(s) # [3,[1, 2, 2, 3, 3, 3, 1, 2, 1, 4]]
print(s(4)) # 3 
t = eval(repr(s))
print(t) # [3,[1, 2, 2, 3, 3, 3, 1, 2, 1, 4]]
print(s == t) # True
a = SequentieIdentiek(2, [1, 2, 3])
b = SequentieIdentiek(2, [1, 2, 3, 4, 5])
c = a + b 
print(c) # [2,[1, 2, 3, 1, 2, 3, 4, 5]]
c = c + b
print(c) # [2,[1, 2, 3, 1, 2, 3, 4, 5, 4, 5]]
d = c - a
print(d) # [2,[1, 2, 3, 4, 5, 4, 5]]
v = SequentieIdentiek(2, [1, 2, 3, 4, 5, 6])
e = d - v
print(e) # [2,[4, 5]]