def __init__(self):
self.ar = []
self.med = None
self.max_pq = PriorityQueue(100, MAX_PQ)
self.max_pq_len = 0
self.min_pq = PriorityQueue(100, MIN_PQ)
self.min_pq_len = 0
self.processed_first_two = False
class KthLargest(object):
def __init__(self, k):
self.k = k
self.min_pq = PriorityQueue(k, MIN_PQ)
def insert(self, element):
if self.min_pq.get_size() < self.k:
self.min_pq.insert(element)
return
if element <= self.min_pq.peek():
return
self.min_pq.delete_top()
self.min_pq.insert(element)
def get_kth_largest(self):
return self.min_pq.peek()
# k = KthLargest(3)
# k.insert(2)
# k.insert(3)
# k.insert(1)
# print k.get_kth_largest()
# k.insert(0)
# print k.get_kth_largest()
# k.insert(4)
# k.insert(7)
# print k.get_kth_largest()
def get_char_counts(string):
hm = {}
for c in string:
if c in hm:
hm[c] += 1
else:
hm[c] = 1
keys = hm.keys()
pq = PriorityQueue(len(keys), MAX_PQ)
for k in keys:
pq.insert(Node(k, hm[k]))
return pq
def compute_range(array, N):
k = len(array)
minpq = PriorityQueue(k, MIN_PQ)
_min = maxint
_max = -maxint
for i in range(k):
el = Element(array[i][0], 0, i)
minpq.insert(el)
if el.data < _min:
_min = el.data
if el.data > _max:
_max = el.data
start = _min
end = _max
rang = _max - _min
while True:
min_el = minpq.delete_top()
_min = min_el.data
new_range = _max - _min
if new_range < rang:
rang = new_range
start = _min
end = _max
nxt_array = min_el.array
nxt_idx = min_el.index + 1
if nxt_idx < N:
nxt_el = Element(array[nxt_array][nxt_idx], nxt_idx, nxt_array)
if nxt_el.data > _max:
_max = nxt_el.data
else:
break
minpq.insert(nxt_el)
return start, end
class KMostFrequentWords:
def __init__(self, words, k):
self.words = words
self.trie = TrieDS()
self.min_heap = PriorityQueue(k, MIN_PQ)
self.k = k
self.pre_process()
def pre_process(self):
# inserting first k words
li = []
for i in range(self.k):
w = self.words[i]
if self.trie.get(w) is None:
obj = WordFreq(w, 0)
self.trie.put(w, obj)
li.append(obj)
obj = self.trie.get(w)
obj.freq += 1
for ob in li:
self.min_heap.insert(ob)
# adding remaining items
for i in range(self.k, len(self.words)):
w = self.words[i]
obj = self.trie.get(w)
if obj is None:
obj = WordFreq(w, 1)
self.trie.put(obj)
if obj.freq <= self.min_heap.peek().freq:
continue
else:
self.min_heap.delete_top()
self.min_heap.insert(obj)
def get_k_most_freq(self):
return self.min_heap.array
def print_sorted(array):
k = len(array)
min_pq = PriorityQueue(k, MIN_PQ)
for i in range(k):
min_pq.insert(Element(array[i][0], 0, i))
while True:
if min_pq.is_empty():
break
element = min_pq.delete_top()
print element,
nxt_array = element.array
nxt_index = element.index + 1
if nxt_index == len(array[nxt_array]):
continue
nxt_el = array[nxt_array][nxt_index]
min_pq.insert(Element(nxt_el, nxt_index, nxt_array))
def re_arrange(string):
li = list(string)
n = len(li)
cc = [0 for i in range(26)]
for i in xrange(len(string)):
c = string[i]
idx = ord(c) - ord('a')
cc[idx] += 1
if cc[idx] > ceil(n / 2.0):
print cc[idx]
return 'Nope'
pq_size = 0
for i in range(len(cc)):
if cc[i] != 0:
pq_size += 1
pq = PriorityQueue(pq_size, MAX_PQ)
for i in xrange(26):
if cc[i] != 0:
pq.insert(CharFreq(chr(i + ord('a')), cc[i]))
res = []
while not pq.is_empty():
first = pq.delete_top()
res.append(first.char)
first.freq -= 1
second = None
if not pq.is_empty():
second = pq.delete_top()
res.append(second.char)
second.freq -= 1
if first.freq > 0:
pq.insert(first)
if second is not None and second.freq > 0:
pq.insert(second)
return ''.join(res)
def __init__(self, k):
self.k = k
self.min_pq = PriorityQueue(k, MIN_PQ)
def __init__(self, words, k):
self.words = words
self.trie = TrieDS()
self.min_heap = PriorityQueue(k, MIN_PQ)
self.k = k
self.pre_process()
class RunningMedian(object):
def __init__(self):
self.ar = []
self.med = None
self.max_pq = PriorityQueue(100, MAX_PQ)
self.max_pq_len = 0
self.min_pq = PriorityQueue(100, MIN_PQ)
self.min_pq_len = 0
self.processed_first_two = False
def balance(self):
if abs(self.max_pq_len - self.min_pq_len) > 1:
if self.max_pq_len > self.min_pq_len:
self.min_pq.insert(self.max_pq.delete_top())
self.min_pq_len += 1
self.max_pq_len -= 1
else:
self.max_pq.insert(self.min_pq.delete_top())
self.max_pq_len += 1
self.min_pq_len -= 1
def compute_median(self):
if self.max_pq_len > self.min_pq_len:
self.med = '%.2f' % self.max_pq.array[1]
elif self.min_pq_len > self.max_pq_len:
self.med = '%.2f' % self.min_pq.array[1]
else:
self.med = '%.2f' % (
(self.min_pq.array[1] + self.max_pq.array[1]) / 2)
def add(self, num):
if len(self.ar) == 0:
self.ar.append(num)
self.med = '%.2f' % num
elif len(self.ar) == 1:
self.ar.append(num)
self.med = '%.2f' % ((self.ar[0] + self.ar[1]) / 2)
else:
if not self.processed_first_two:
less = 0 if self.ar[0] < self.ar[1] else 1
grtr = 0 if less == 1 else 1
self.max_pq.insert(self.ar[less])
self.min_pq.insert(self.ar[grtr])
self.max_pq_len += 1
self.min_pq_len += 1
self.processed_first_two = True
if num <= self.max_pq.array[1]:
self.max_pq.insert(num)
self.max_pq_len += 1
else:
self.min_pq.insert(num)
self.min_pq_len += 1
self.balance()
self.compute_median()
def get_median(self):
return self.med
def setUp(self):
self.max_pq = PriorityQueue(10, MAX_PQ)
self.min_pq = PriorityQueue(10, MIN_PQ)
class PriorityQueueTest(TestCase):
def setUp(self):
self.max_pq = PriorityQueue(10, MAX_PQ)
self.min_pq = PriorityQueue(10, MIN_PQ)
def test_max_pq(self):
self.max_pq.insert(6)
self.max_pq.insert(1)
self.max_pq.insert(2)
self.max_pq.insert(3)
self.assertEqual(6, self.max_pq.delete_top())
self.assertEqual(3, self.max_pq.delete_top())
self.assertEqual(2, self.max_pq.delete_top())
self.assertEqual(1, self.max_pq.delete_top())
def test_min_pq(self):
self.min_pq.insert(6)
self.min_pq.insert(1)
self.min_pq.insert(2)
self.min_pq.insert(3)
self.assertEqual(1, self.min_pq.delete_top())
self.assertEqual(2, self.min_pq.delete_top())
self.assertEqual(3, self.min_pq.delete_top())
self.assertEqual(6, self.min_pq.delete_top())