jonathanagustin

class Solution:
    
    def minCostClimbingStairs(self, costs: List[int]) -> int:
        
        n = len(costs)
        
        if n == 2:
            return min(costs[0], costs[1])
        
        dp = [0] * n

jonathanagustin

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        

jonathanagustin

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    
    def levelOrder(self, root: TreeNode) -> List[List[int]]:
        

jonathanagustin

order = 'abcdefghijklmnopqrstuvwxyz'
character_order = {c: i for i, c in enumerate(order)}

jonathanagustin

int main() {
  int Q; cin >> Q;
  map<long long, int> points;
  for (int i = 0; i < Q; i++) {
    long long l, r; cin >> l >> r;
    points[l]++;
    points[r + 1]--;
  }

  int best = 0, cur = 0;

jonathanagustin

import heapq

class Neg():
    def __init__(self, x):
        self.x = x

    def __cmp__(self, other):
        return -cmp(self.x, other.x)

def maxheappush(heap, item):

jonathanagustin

from functools import wraps
from time import time
def measure(func):
    @wraps(func)
    def _time_it(*args, **kwargs):
        start = int(round(time() * 1000))
        try:
            return func(*args, **kwargs)
        finally:
            end_ = int(round(time() * 1000)) - start

jonathanagustin

Tip: To make the code more efficient, you can use the deque object from the collections module instead of a list, for implementing queue. This way you can use the popleft() method instead of the pop(0) built-in function on queue. This will result in a quicker code as popleft() has a time complexity of O(1) while pop(0) has O(n).

Deque (Doubly Ended Queue) in python is implemented using the module “collections“. Deque is preferred over list in the cases where we need quicker append and pop operations from both the ends of container, as deque provides an O(1) time complexity for append and pop operations as compared to list which provides O(n) time complexity.

jonathanagustin

def buildGraph(edges):
    from collections import defaultdict
    graph = defaultdict(list)
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u) # delete this line if directed graph

jonathanagustin

import string

# make table for translate() to remove punctuation
table = str.maketrans('', '', string.punctuation)

my_string = "!!!asdf"

new_string = my_string.translate(table)

print(new_string)