Python PriorityQueue.get方法代码示例

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
class KthLargestV1:

    def __init__(self, k: int, nums: List[int]):
        self.pq = PriorityQueue(maxsize=k)
        for _, num in enumerate(nums):
            if self.pq.full():
                q_top = self.pq.get()
                if q_top >= num:
                    self.pq.put(q_top)
                else:
                    self.pq.put(num)
            else:
                self.pq.put(num)

    def add(self, val: int) -> int:
        if self.pq.full():
            q_top = self.pq.get()
            if q_top >= val:
                result = q_top
                self.pq.put(q_top)
            else:
                self.pq.put(val)
                result = self.pq.get()
                self.pq.put(result)
        else:
            self.pq.put(val)
            result = self.pq.get()
            self.pq.put(result)
        return result

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def huffman(string):
    count = Counter()
    q = PriorityQueue()

    for letter in string:
        count[letter] += 1

    string_counted = [[weight, [value, '']] for value, weight in count.items()]

    for item in string_counted:
        q.put([item[0], item[1]])

    while q.qsize() > 1:

        left = q.get()
        right = q.get()

        for x in left[1:]:
            x[1] = '0' + x[1]

        for x in right[1:]:
            x[1] = '1' + x[1]

        q.put([left[0] + right[0]] + left[1:] + right[1:])

    tree = q.get()

    tree = tree[1:]
    code = dict()

    for pair in tree:
        code[pair[0]] = pair[1]

    return code

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def solve_q1(text):
    from queue import PriorityQueue
    freq = dict()
    for i in text:
        if i not in freq:
            freq[i] = 0
        freq[i] += 1

    q = PriorityQueue()
    for i in freq:
        n = HuffmanNode()
        n.f = freq[i]
        n.c = i
        q.put(n)

    while q.qsize() > 1:
        a = q.get()
        b = q.get()
        c = HuffmanNode()
        c.f = a.f + b.f
        c.l = a
        c.r = b
        q.put(c)

    root = q.get()
    ret = 0
    for i in freq:
        ret += freq[i] * root.get(i)
    print(ret)

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
class JobQueue(object):
    def __init__(self):
        self.queue = PriorityQueue()
        self.last_enqueued = None
        self.logger = logging.getLogger(self.__class__.__name__)

    def put(self, job, next_t=0):
        self.logger.debug("Putting a {} with t={}".format(job.__class__.__name__, next_t))
        re_enqueued_last = self.last_enqueued == job
        self.queue.put((next_t, job))
        self.last_enqueued = job
        return re_enqueued_last

    def tick(self):
        now = time.time()

        self.logger.debug("Ticking jobs with t={}".format(now))
        while not self.queue.empty():
            t, j = self.queue.queue[0]
            self.logger.debug("Peeked a {} with t={}".format(j.__class__.__name__, t))

            if t < now:
                self.queue.get()
                self.logger.debug("About time! running")
                j.run()
                self.put(j, now + j.INTERVAL)
                continue

            self.logger.debug("Next task isn't due yet. Finished!")
            break

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def create_tree(to_comprime_text):
    separated_chars = Counter(to_comprime_text)
    
    nodes = {}
        
    for char in separated_chars:
        nodes[char] = Node(separated_chars[char], char)
    
    q = PriorityQueue()
    
    for node in nodes:
        q.put((nodes[node].get_node_value(), node))
    
    while q.qsize() > 1:
        left = q.get()
        right = q.get()
        
        nodes[left[1]].set_binary_node_value(0)
        nodes[right[1]].set_binary_node_value(1)
        
        node_representation = nodes[left[1]].get_node_representation() + nodes[right[1]].get_node_representation()
        node_value = nodes[left[1]].get_node_value() + nodes[right[1]].get_node_value()
        
        nodes[node_representation] = Node(node_value, node_representation)
        
        nodes[node_representation].set_left_node(nodes[left[1]])
        nodes[node_representation].set_right_node(nodes[right[1]])
        nodes[left[1]].set_back_node(nodes[node_representation])
        nodes[right[1]].set_back_node(nodes[node_representation])
        
        q.put((nodes[node_representation].get_node_value(), node_representation))
    
    return nodes

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
class HeapMultiSet(object):
    def __init__(self, prioritizer):
        self.prioritizer = prioritizer
        self.heap = PriorityQueue()
        self.counts = {}
        self.length = 0

    def offer(self, value):
        # Add the value to the heap if it does not exist yet.
        if (value not in self.counts or self.counts[value] <= 0):
            # Calculate a priority for the value
            priority = self.prioritizer(value)
            self.heap.put((priority, value))
            # Track the count of the value
            self.counts[value] = 0

        self.counts[value] += 1

        # Update the size of the heap
        self.length += 1

    def peek(self):
        if (self.heap.empty()):
            return None
        (priority, value) = self.heap.queue[0]
        return value

    def remove(self, value):
        if (not self.contains(value)):
            return False
        if (self.counts[value] > 0):
            self.length -= 1
            self.counts[value] = self.counts[value] - 1
            self.fix_top()
        return True

    def pop(self):
        if (self.heap.empty()):
            return None
        value = self.peek()
        if (self.counts[value] > 0):
            self.counts[value] -= 1
            self.length -= 1
            self.fix_top()
        return value

    def fix_top(self):
        while (not self.heap.empty()):
            (priority, value) = self.heap.queue[0]
            if (self.counts[value] > 0):
                break
            self.heap.get()

    def contains(self, value):
        return value in self.counts and self.counts[value] > 0

    def __len__(self):
        return self.length

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def printSorted(l):
#     printList(l)

    queue = PriorityQueue()
    for i in l:
        queue.put(i)
    while not queue.empty():
#         print(queue.get(),  "\t", end="")
        queue.get()

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
 def test_priority(self):
     from queue import PriorityQueue
     q = PriorityQueue()
     tiP1 = tt.TodoItem('vacuum bedroom', priority=1)
     tiP2 = tt.TodoItem('play video games', priority=2)
     q.put(tiP1)
     q.put(tiP2)
     self.assertEqual(q.get(), tiP1)
     self.assertTrue(q.get(), tiP2)

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def main():
    global CREATURE_COUNT
    if process_targeting_form():
        c0 = []
        c1 = PriorityQueue()
        result_out('[+]\tLoading DB...')
        #load in creatures from DB
        lc = load_DB()
        loaded_creatures = lc.split('\n')
        #finish loading
        result_out('[+]\tSuccess')
        result_out('[+]\tCreating initial batch of creatures...')
        cl = create_creatures(CREATURE_COUNT, GENOME_LENGTH, tools)
        generation = 0
        for i in cl:
            c1.put((100, i))
        for i in loaded_creatures:
            c1.put((50, Creature(0, i)))
            for ii in range(0, GENE_POOL_INFLUENCE-1):
                c1.put((50, Creature(0, mutate(i))))
        result_out('[+]\tSuccess')
        result_out('[+]\tPre-breeding in loaded creatures with the population for great success')
        while not c1.empty():
            c = c1.get()[1]
            c0.append(c)
        c1 = breed_it(c0)
        c1 = c0
        result_out('[+]\tSuccess')
        exploit_found = 0
        while exploit_found == 0 and c1.qsize() > 0::
            generation += 1
            CREATURE_COUNT = c1.qsize()
            result_out('[>]\tRunning with creature_count %d,\tgeneration %d' % (CREATURE_COUNT, generation))
            c2 = PriorityQueue(0)
            cached_c = 0
            total_c = 0
            while not c1.empty():
                c = c1.get()[1]
                total_c += 1
                if c.modified == 0:
                    cached_c += 1
                if fitnessfunction(c) == 1:
                    exploit_found = 1
                    break
                c2.put((c.score, c))
            result_out('[i]\tEfficiency %s, cached[%d], total[%d]' % (str((total_c-cached_c) * 1.0 / total_c),cached_c,total_c))
            c3 = cull_it(c2)
            c4 = []
            while not c3.empty():
                c = c3.get()[1]
                c4.append(c)
            c1 = breed_it(c4)
        if exploit_found > 0:
            result_out('[i]\tExploit found in %d seconds with %d requests' % (abs(int(start_time - time.time())), REQ_TOTAL))
        else:
            result_out('No exploits found')

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def solve(n, xs, k):
    kidx = k + 1
    pq = PriorityQueue()
    for i in range(kidx):
        pq.put(Value(xs[i]))
    for i in range(kidx, n):
        v = xs[i]
        max_v = pq.get()
        pq.put(Value(min(max_v.v, v)))
    return pq.get().v

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
    def test_work_in_priority_queue(self):
        queue = PriorityQueue()
        priorities = [self.medium_priority, self.low_priority, self.high_priority]

        for priority in priorities:
            queue.put(priority)

        self.assertListEqual(sorted(priorities), [self.high_priority, self.medium_priority, self.low_priority])
        self.assertEqual(queue.get(), self.high_priority)
        self.assertEqual(queue.get(), self.medium_priority)
        self.assertEqual(queue.get(), self.low_priority)

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
def huffTree(freqs):
    p = PriorityQueue()
    for i, fr in enumerate(freqs):
        if fr:
            # print(i, fr)
            p.put((fr, HuffNode(info=i)))

    while p.qsize() > 1:
        l, r = p.get(), p.get()
        n = HuffNode(left=l[1], right=r[1])
        p.put((l[0]+r[0], n))

    return p.get()[1]

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
    def classify(self):
        classified = dict()
        ordered_packages = PriorityQueue()
        for p in self.packages:
            if p.ready_for_upload:
                cls = 'ready_for_upload'
            elif p.has_rc_bugs:
                cls = 'rc_bugs'
            elif p.missing_tag:
                cls = 'missing_tag'
            elif not p.tags:
                cls = 'new'
            elif p.newer_upstream:
                cls = 'new_upstream'
            elif p.watch_problem:
                cls = 'watch_problem'
            elif p.bugs:
                cls = 'bugs'
            elif not p.is_tagged:
                cls = 'wip'
            else:
                cls = 'other'

            package_popcon = popcon.package(p.name)
            if package_popcon:
                ordered_packages.put((-package_popcon[p.name], cls, p))
        while ordered_packages.empty() is False:
            _, cls, package = ordered_packages.get()
            classified.setdefault(cls, []).append(package)

        return classified

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
    def next_enrichment(self, cookie: Cookie) -> Optional[Enrichment]:
        """
        Loads the next set of data not present in the known data given (the "enrichment").

        Returns `None``if all enrichments have already been applied to the cookie.
        :param cookie: the data already known
        :return: the loaded enrichment
        """
        enrichment_loaders_priority_queue = PriorityQueue()
        for enrichment_loader in self.enrichment_loaders:
            enrichment_loaders_priority_queue.put(enrichment_loader)

        while not enrichment_loaders_priority_queue.empty():
            enrichment_loader = enrichment_loaders_priority_queue.get()

            enrich = False
            try:
                enrich = enrichment_loader.can_enrich(cookie)
            except Exception as e:
                logging.error("Error checking if enrichment can be applied to cookie; Enrichment loader: %s;"
                              "Target Cookie: %s; Error: %s" % (enrichment_loader, cookie.identifier, e))

            if enrich:
                try:
                    return enrichment_loader.load_enrichment(cookie)
                except Exception:
                    logging.error("Error loading enrichment; Enrichment loader: %s; Target Cookie: %s; Error: %s"
                                  % (enrichment_loader, cookie.identifier, traceback.format_exc()))

        return None

# 需要导入模块: from queue import PriorityQueue [as 别名]
# 或者: from queue.PriorityQueue import get [as 别名]
	def bestFirstSearch(self, startNode, goalNode, heuristic):
        	bestFitstQueue = PriorityQueue(0)
        
	        visitedNode = {}
	        parent = {}
	        utility = Utility()
	        goalNodeStateDict = utility.getGoalNodeStateDict(goalNode)
	        bestFitstQueue.put((1, startNode))
	        while not(bestFitstQueue.empty()):
	            poppedTuple = bestFitstQueue.get()
	            self.nodesVisited+=1
	            popped = poppedTuple[1]
	            if (popped == goalNode):
	#                 print popped==goalNode
	                return self.backtrack(popped)
	            
	            else:
	                visitedNode[popped.stringRep]=popped
	                if self.maxDepth < popped.level:
	                    self.maxDepth = popped.level
	                popped.expand()
	                
	                for child in popped.children:
	                    if child.stringRep not in visitedNode:
	                     heuristicOfChild = utility.getHeuristic(child, goalNode, heuristic, goalNodeStateDict)
	                     bestFitstQueue.put((heuristicOfChild, child))
	                     self.maxQueueSize +=1