Klasse TweeContainer

In twee containers is plaats voor een gelijk aantal dozen $$N$$. Elke doos heeft een bepaalde massa, en deze massa is strikt positief en geheel. Het is de bedoeling om de containers zo te vullen dat hun totaalmassa's zo dicht mogelijk bij elkaar liggen. Dit kan gerealiseerd worden door dozen uit de containers te wisselen.

Schrijf een klasse TweeContainer, met volgende methoden:

• een constructor met 2 argumenten, namelijk twee lijsten van gelijke lengte $$N$$. Elke lijst stelt de inhoud van een container voor, waarbij elk element van de lijst de massa van een doos voorstelt. Je mag aannemen dat beide argumenten minstens 1 element bevatten, en dat alle elementen van de argumenten strikt positief zijn.
• een methode __str__() die de inhoud van de TweeContainer terruggeeft in de volgende gedaante : $$\verb![lijst_0:lijst_1]!$$
. Hierbij worden de lijsten in hun standaardgedaante weergegeven (dus door oproepen van de methode __str__() op deze lijsten.
• de operator == heeft als linkeroperand en rechteroperand telkens een object van de klasse TweeContainer, namelijk a en b. Deze operator levert de waarde True op als beide TweeContainers op een gelijkwaardige manier gevuld zijn. Dit betekent concreet dat van de TweeContainer gelijk zijn indien:
  • lijst 0 en lijst 1 van a een permutaties zijn van resp. lijst 0 en lijst 1 van b
  • OF lijst 0 en lijst 1 van a een permutaties zijn van resp. lijst 1 en lijst 0 van b
• de operator *= heeft als linker operand een object van de klasse TweeContainer en als rechteroperand een tuple, bestaande uit twee gehele getallen (i,j) met $$0 \le i,j \lt N$$. Het resultaat is dat in de TweeContainer de dozen met index $$i$$ uit de eerste container en met index $$j$$ uit de tweede container van plaats gewisseld zijn.
• de functie onbalans(), zonder argumenten, levert de absolute waarde van het verschil in totale massa van beide containers in de TweeContainer

Voorbeeld

a = TweeContainer([1, 2, 3, 3], [5, 2, 1, 1])
b = TweeContainer([3, 1, 2, 3], [1, 2, 1, 5])
c = TweeContainer([1, 2, 3, 3], [1, 2, 1, 6])
str(a)					# '[[1, 2, 3, 3]:[5, 2, 1, 1]]'
str(b)					# '[[3, 1, 2, 3]:[1, 2, 1, 5]]'
str(c)					#'[[1, 2, 3, 3]:[1, 2, 1, 6]]'
a == b					# True
a == c					# False
b == c					# False
a.onbalans()			# 0
b.onbalans()			# 0
c.onbalans()			# 1
a *= (1, 2)				# '[[1, 1, 3, 3]:[5, 2, 2, 1]]'
c *= (2, 3)				# [[1, 2, 6, 3]:[1, 2, 1, 3]]' 

Klasse TweeContainerGulzig

Programmeer ook de klasse TweeContainerGulzig. Deze klasse erft over van de klasse TweeContainer, en bevat een extra-methode evenwicht(), zonder argumenten. Deze methode poogt een paar containers in de TweeContainer te wisselen, en gaat hierbij als volgt tewerk:

• indien beide containers evenveel massa bevatten, gebeurt er niets
• in het andere geval: zoek de zwaarste massa in de container die het meest weegt, en de lichtste massa in de container die het minst weegt. Indien een wissel de onbalans laat dalen, voer je deze wissel door. In het andere geval, gebeurt er niets. Indien er meerdere keuzes zijn om de zwaarste of lichtste massa te bepalen, dan kies je de massa met kleinste index.

Voorbeeld

d = TweeContainerGulzig([5, 2, 6, 5, 2, 2], [1, 7, 1, 8, 7, 10])
str(d)					# '[[5, 2, 6, 5, 2, 2]:[1, 7, 1, 8, 7, 10]]'
d.evenwicht()
str(d)					# '[[5, 10, 6, 5, 2, 2]:[1, 7, 1, 8, 7, 2]]'

c = TweeContainerGulzig([7, 2, 3, 3], [5, 2, 1, 4])
str(c)					# '[[7, 2, 3, 3]:[5, 2, 1, 4]]'
c.evenwicht()
str(c)					# '[[7, 2, 3, 3]:[5, 2, 1, 4]]'

Klasse TweeContainerPaar

Programmeer nu ook de klasse TweeContainerPaar. Deze klasse erft ook over van de klasse TweeContainer, en bevat ook een extra-methode evenwicht(), zonder argumenten. Ook deze methode poogt een paar containers in de TweeContainer te wisselen, namelijk:

• indien beide containers evenveel massa bevatten, gebeurt er niets
• in het andere geval ga je op zoek naar het tuple (i,j) dat de onbalans zo klein mogelijk maakt, indien je de doos met index $$i$$ uit lijst 0 en de doos met index $$j$$ uit lijst 1 wisselt, meest laat dalen. Pas deze wissel toe. Indien er meerdere tuples $$(i, j)$$ zijn die dezelfde daling in onbalans realiseren, kies je het tuple met kleinste $$i$$- waarde. Zijn er nog altijd meerdere mogelijkheden, dan kies je het tuple met kleinste $$i$$- en $$j$$-waarde.

Voorbeeld

c = TweeContainerPaar([7, 2, 3, 3], [5, 2, 1, 4])
str(c)		# '[[7, 2, 3, 3]:[5, 2, 1, 4]]'

c.evenwicht()
str(c)		# '[[5, 2, 3, 3]:[7, 2, 1, 4]]'

c.evenwicht()
str(c)		# '[[5, 2, 3, 3]:[7, 2, 1, 4]]'