def test_equals(self):
treesetA = TreeSet()
for i in [5, 19, 21, 25]:
treesetA.add(i)
treesetB = TreeSet()
for i in [19, 5, 21, 25]:
treesetB.add(i)
treesetC = TreeSet()
for i in [21, 19, 5, 25]:
treesetC.add(i)
self.assertTrue(treesetA == treesetB)
self.assertTrue(treesetA == treesetC)
self.assertTrue(treesetC == treesetB)
treesetD = [19, [5, [], []], [21, [], [26, [], []]]]
treesetE = [19, [6, [], []], [21, [], [25, [], []]]]
treesetD = TreeSet()
for i in [19, 5, 21, 26]:
treesetD.add(i)
treesetE = TreeSet()
for i in [19, 6, 21, 25]:
treesetE.add(i)
self.assertFalse(treesetA == treesetD)
self.assertFalse(treesetA == treesetE)
self.assertTrue(treesetA != treesetD)
self.assertTrue(treesetA != treesetE)
def test_contains(self):
tree = TreeSet(8)
for i in [3, -1, 6, 4, 7, 10, 14, 13]:
tree.add(i)
for i in [3, -1, 6, 4, 7, 10, 14, 13]:
self.assertTrue(i in tree)
for i in [-2, 0, 15]:
self.assertFalse(i in tree)
self.assertTrue(i not in tree)
def test_treeset(self):
ts = TreeSet([3,7,2,7,1,3])
self.assertEqual(ts, [1, 2, 3, 7])
ts.add(4)
self.assertEqual(ts, [1, 2, 3, 4, 7])
ts.add(4)
self.assertEqual(ts, [1, 2, 3, 4, 7])
ts.remove(7)
self.assertEqual(ts, [1, 2, 3, 4])
ts.remove(5)
self.assertEqual(ts, [1, 2, 3, 4])
ts.addAll([3,4,5,6])
self.assertEqual(ts, [1, 2, 3, 4, 5, 6])
ts.pop(3)
self.assertEqual(ts, [1, 2, 3, 5, 6])
self.assertEqual(ts[0], 1)
self.assertEqual(ts[-1], 6)
self.assertTrue(1 in ts)
self.assertFalse(100 in ts)
for i, element in enumerate(TreeSet([1,3,1])):
if i==0:
self.assertEqual(element, 1)
elif i==1:
self.assertEqual(element, 3)
else:
raise Exception
ts_copy = ts.clone()
self.assertEqual(ts, [1, 2, 3, 5, 6])
self.assertEqual(ts.floor(4), 3)
self.assertEqual(ts.ceiling(4), 5)
self.assertEqual(ts.floor(3), 3)
self.assertEqual(ts.ceiling(3), 3)
ts.clear()
self.assertEqual(ts._treeset, [])
def test_treeset(self):
ts = TreeSet([3, 7, 2, 7, 1, 3])
self.assertEqual(ts, [1, 2, 3, 7])
ts.add(4)
self.assertEqual(ts, [1, 2, 3, 4, 7])
ts.add(4)
self.assertEqual(ts, [1, 2, 3, 4, 7])
ts.remove(7)
self.assertEqual(ts, [1, 2, 3, 4])
ts.remove(5)
self.assertEqual(ts, [1, 2, 3, 4])
ts.addAll([3, 4, 5, 6])
self.assertEqual(ts, [1, 2, 3, 4, 5, 6])
ts.pop(3)
self.assertEqual(ts, [1, 2, 3, 5, 6])
self.assertEqual(ts[0], 1)
self.assertEqual(ts[-1], 6)
self.assertTrue(1 in ts)
self.assertFalse(100 in ts)
for i, element in enumerate(TreeSet([1, 3, 1])):
if i == 0:
self.assertEqual(element, 1)
elif i == 1:
self.assertEqual(element, 3)
else:
raise Exception
ts_copy = ts.clone()
self.assertEqual(ts, [1, 2, 3, 5, 6])
self.assertEqual(ts.floor(4), 3)
self.assertEqual(ts.ceiling(4), 5)
self.assertEqual(ts.floor(3), 3)
self.assertEqual(ts.ceiling(3), 3)
ts.clear()
self.assertEqual(ts._treeset, [])
def test_add_emptyset(self):
tree = TreeSet()
for i in [3, 1, 2, 4]:
tree.add(i)
# Check root
self.assertEquals(3, tree._root)
# check left child
self.assertEquals(1, tree._left._root)
self.assertIsNone(tree._left._left)
# check right child
self.assertEquals(4, tree._right._root)
self.assertIsNone(tree._right._left)
self.assertIsNone(tree._right._right)
# Check left->right grand child
self.assertEquals(2, tree._left._right._root)
self.assertIsNone(tree._left._right._left)
self.assertIsNone(tree._left._right._right)
class TreeMap(dict):
"""
"TreeMap" is a dictionary with sorted keys similar to java TreeMap.
Keys, iteration, items, values will all return values ordered by key.
Otherwise it should behave just like the builtin dict.
"""
def __init__(self, seq=None, **kwargs):
if seq is None:
super().__init__(**kwargs)
else:
super().__init__(seq, **kwargs)
self.sorted_keys = TreeSet(super().keys())
def __setitem__(self, key, value):
super().__setitem__(key, value)
self.sorted_keys.add(key)
def __delitem__(self, key):
super().__delitem__(key)
self.sorted_keys.remove(key)
def keys(self):
return self.sorted_keys
def items(self):
return [(k, self[k]) for k in self.sorted_keys]
def __iter__(self):
for k in self.sorted_keys:
yield k
def values(self):
for k in self.sorted_keys:
yield self[k]
def clear(self):
super().clear()
self.sorted_keys.clear()
def test_union(self):
treesetA = TreeSet()
for i in [5, 19, 21, 25]:
treesetA.add(i)
treesetB = TreeSet()
for i in [19, 6, 1, 5]:
treesetB.add(i)
treesetC = TreeSet()
for i in [19, 6, 1, 5, 21, 25]:
treesetC.add(i)
self.assertEqual(treesetC, treesetA.union(treesetB))
self.assertEqual(treesetA, treesetA.union(TreeSet()))
def test_remove(self):
treesetA = TreeSet()
for i in [5, 19, 21, 25]:
treesetA.add(i)
treesetA.remove(21)
treesetB = TreeSet()
for i in [5, 19, 25]:
treesetB.add(i)
self.assertEquals(treesetA, treesetB)
treesetA.remove(5)
treesetA.remove(25)
treesetC = TreeSet()
for i in [19]:
treesetC.add(i)
self.assertEquals(treesetA, treesetC)
treesetA.remove(19)
self.assertTrue(treesetA.isempty())
def addIndex(self, index):
if not self.rowsIndexes:
rowsIndexes = TreeSet([])
rowsIndexes.add(index)
def player_split_get_teams_scores(A):
#sort the array input
A.sort()
#initialize the variables
partition1 = list()
partition2 = list()
i = 0
j = len(A)-1
part1Sum = 0
part2Sum = 0
diffSum = 0
unused = TreeSet([])
for i in range (len(A)):
unused.add(i)
while len(unused) > 0:
i = unused[0]
j = unused[-1]
diffSum = part1Sum-part2Sum
#special case handling when the array is not multiple of 4 then
if len(unused) < 4:
#remaining item placed smaller partition
if len(unused) == 1:
if diffSum > 0:
partition2.append(A[i])
part2Sum += A[i]
else:
partition1.append(A[i])
part1Sum += A[i]
#max in smaller and min in larger partition
elif len(unused) == 2:
maxx = max(A[i], A[j])
minn = min(A[i], A[j])
if diffSum > 0:
partition2.append(maxx)
partition1.append(minn)
part2Sum += maxx
part1Sum += minn
else:
partition1.append(maxx)
partition2.append(minn)
part1Sum += maxx
part2Sum += minn
#min, middle in smaller particion and max in larger particion
elif len(unused) == 3:
unused.remove(i)
unused.remove(j)
middle = unused[0]
if diffSum > 0:
if A[i]+A[middle] > A[j]:
partition2.append(A[i])
partition2.append(A[middle])
partition1.append(A[j])
part2Sum += A[i]+A[middle]
part1Sum += A[j]
else:
partition2.append(A[j])
partition1.append(A[i])
partition1.append(A[middle])
part1Sum += A[i]+A[middle]
part2Sum += A[j]
else:
if A[i]+A[middle] > A[j]:
partition1.append(A[i])
partition1.append(A[middle])
partition2.append(A[j])
part1Sum += A[i]+A[middle]
part2Sum += A[j]
else:
partition1.append(A[j])
partition2.append(A[i])
partition2.append(A[middle])
part2Sum += A[i]+A[middle]
part1Sum += A[j]
diffSum = part1Sum - part2Sum
break
#take the largest and the smallest element to create a pair
pairSum = A[i]+A[j]
if diffSum > 0:
particion = 2
else:
particion = 1
if particion == 1 :
partition1.append(A[i])
partition1.append(A[j])
part1Sum += pairSum
else:
partition2.append(A[i])
partition2.append(A[j])
part2Sum += pairSum
diffSum = part1Sum - part2Sum
#used pair (i, j)
unused.remove(i)
unused.remove(j)
#j last element
j = unused[-1]
buddyIndex = unused[0]
minPairSumDiff = float('-inf')
#find such buddy A[k], i<=k<j such that value of ((A[j]+A[k])-pairSum) is minimized
for k in range(buddyIndex, j, 1):
if k not in unused:
continue
compPairSum = A[j]+A[k]
pairSumDiff = abs(pairSum-compPairSum)
if pairSumDiff < minPairSumDiff:
minPairSumDiff = pairSumDiff
buddyIndex = k
#add pair (j,buddyIndex) to the other partition
if j != buddyIndex:
pairSum = A[j]+A[buddyIndex]
if particion == 2:
partition1.append(A[j])
partition1.append(A[buddyIndex])
part1Sum += pairSum
else:
partition2.append(A[j])
partition2.append(A[buddyIndex])
part2Sum += pairSum
#used pair (j, buddyIndex)
unused.remove(j)
unused.remove(buddyIndex)
#optimize by swapping a larger elements in large partition with an small element in smaller partition
if diffSum != 0:
partition1.sort()
partition2.sort()
diffSum = part1Sum-part2Sum
if diffSum > 0:
largerPartition = partition1
smallerPartition = partition2
else:
largerPartition = partition2
smallerPartition = partition1
prevDiff = abs(diffSum)
largePartitonSwapCandidate = -1
smallPartitonSwapCandidate = -1
#swap largest element from large partition and smallest from the smaller partition so that sum difference is minimized
for i in range(len(smallerPartition)):
for j in range(len(largerPartition)-1, -1, -1):
largerVal = largerPartition[j]
smallerVal = smallerPartition[i]
if largerVal <= smallerVal:
continue
diff = abs(prevDiff - 2* abs(largerVal - smallerVal))
if diff == 0:
largerPartition[j] = smallerVal
smallerPartition[i] = largerVal
return [largerPartition, smallerPartition]
elif diff < prevDiff:
prevDiff = diff
largePartitonSwapCandidate = j
smallPartitonSwapCandidate = i
#if found such a pair then swap it.
if largePartitonSwapCandidate >=0 and smallPartitonSwapCandidate >=0:
largerVal = largerPartition[largePartitonSwapCandidate]
smallerVal = smallerPartition[smallPartitonSwapCandidate]
largerPartition[largePartitonSwapCandidate] = smallerVal
smallerPartition[smallPartitonSwapCandidate] = largerVal
return [largerPartition, smallerPartition]
return [partition1, partition2]
